From 7802c26449657b205dcaa47bb6575bb26171c024 Mon Sep 17 00:00:00 2001
From: Frank Denis <github@pureftpd.org>
Date: Sun, 25 Dec 2022 22:04:01 +0100
Subject: [PATCH 1/5] WebAssembly: do not link with --allow-undefined
 unconditionally

In #1622, when targeting WebAsembly, the --allow-undefined flag
became unconditionally added to the linker.

This is not always desirable.

First, this is error prone. Code with references to unkown symbols
will link just fine, but then fail at run-time.

This behavior is inconsistent with all other targets.

For freestanding wasm applications, and applications that only use
WASI, undefined references are better reported at compile-time.

This behavior is also inconsistent with clang itself. Autoconf and
cmake scripts checking for function presence think that all tested
functions exist, but then resulting application cannot run.

For example, this is one of the reasons compilation of Ruby 3.2.0
to WASI fails with zig cc, while it works out of the box with clang.
But all applications checking for symbol existence before compilation
are affected.

This reverts the behavior to the one Zig had before #1622, and
introduces an `import_symbols` flag to ignore undefined symbols,
assuming that the webassembly runtime will define them.
---
 src/Compilation.zig | 2 ++
 src/link.zig        | 1 +
 src/link/Wasm.zig   | 4 +++-
 src/main.zig        | 7 +++++++
 4 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index b385fa5f72ba..ab91e3cbb3d6 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -954,6 +954,7 @@ pub const InitOptions = struct {
     linker_allow_shlib_undefined: ?bool = null,
     linker_bind_global_refs_locally: ?bool = null,
     linker_import_memory: ?bool = null,
+    linker_import_symbols: bool = false,
     linker_import_table: bool = false,
     linker_export_table: bool = false,
     linker_initial_memory: ?u64 = null,
@@ -1811,6 +1812,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             .bind_global_refs_locally = options.linker_bind_global_refs_locally orelse false,
             .compress_debug_sections = options.linker_compress_debug_sections orelse .none,
             .import_memory = options.linker_import_memory orelse false,
+            .import_symbols = options.linker_import_symbols,
             .import_table = options.linker_import_table,
             .export_table = options.linker_export_table,
             .initial_memory = options.linker_initial_memory,
diff --git a/src/link.zig b/src/link.zig
index 450763ac18af..1dadacc2fe23 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -128,6 +128,7 @@ pub const Options = struct {
     compress_debug_sections: CompressDebugSections,
     bind_global_refs_locally: bool,
     import_memory: bool,
+    import_symbols: bool,
     import_table: bool,
     export_table: bool,
     initial_memory: ?u64,
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 346c92ebbef1..1f929da150d5 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -3461,8 +3461,10 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
         } else if (wasm.base.options.entry == null) {
             try argv.append("--no-entry"); // So lld doesn't look for _start.
         }
+        if (wasm.base.options.import_symbols) {
+            try argv.appendSlice(&[_][]const u8{"--allow-undefined"});
+        }
         try argv.appendSlice(&[_][]const u8{
-            "--allow-undefined",
             "-o",
             full_out_path,
         });
diff --git a/src/main.zig b/src/main.zig
index ec0eb74e9338..d9cc147604da 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -517,6 +517,7 @@ const usage_build_generic =
     \\  -dead_strip                    (Darwin) remove functions and data that are unreachable by the entry point or exported symbols
     \\  -dead_strip_dylibs             (Darwin) remove dylibs that are unreachable by the entry point or exported symbols
     \\  --import-memory                (WebAssembly) import memory from the environment
+    \\  --import-symbols               (WebAssembly) import missing symbols from the host environment
     \\  --import-table                 (WebAssembly) import function table from the host environment
     \\  --export-table                 (WebAssembly) export function table to the host environment
     \\  --initial-memory=[bytes]       (WebAssembly) initial size of the linear memory
@@ -718,6 +719,7 @@ fn buildOutputType(
     var linker_allow_shlib_undefined: ?bool = null;
     var linker_bind_global_refs_locally: ?bool = null;
     var linker_import_memory: ?bool = null;
+    var linker_import_symbols: bool = false;
     var linker_import_table: bool = false;
     var linker_export_table: bool = false;
     var linker_initial_memory: ?u64 = null;
@@ -1316,6 +1318,8 @@ fn buildOutputType(
                         }
                     } else if (mem.eql(u8, arg, "--import-memory")) {
                         linker_import_memory = true;
+                    } else if (mem.eql(u8, arg, "--import-symbols")) {
+                        linker_import_symbols = true;
                     } else if (mem.eql(u8, arg, "--import-table")) {
                         linker_import_table = true;
                     } else if (mem.eql(u8, arg, "--export-table")) {
@@ -1837,6 +1841,8 @@ fn buildOutputType(
                     linker_bind_global_refs_locally = true;
                 } else if (mem.eql(u8, arg, "--import-memory")) {
                     linker_import_memory = true;
+                } else if (mem.eql(u8, arg, "--import-symbols")) {
+                    linker_import_symbols = true;
                 } else if (mem.eql(u8, arg, "--import-table")) {
                     linker_import_table = true;
                 } else if (mem.eql(u8, arg, "--export-table")) {
@@ -2977,6 +2983,7 @@ fn buildOutputType(
         .linker_allow_shlib_undefined = linker_allow_shlib_undefined,
         .linker_bind_global_refs_locally = linker_bind_global_refs_locally,
         .linker_import_memory = linker_import_memory,
+        .linker_import_symbols = linker_import_symbols,
         .linker_import_table = linker_import_table,
         .linker_export_table = linker_export_table,
         .linker_initial_memory = linker_initial_memory,

From 4aab8118a771e37566c0c3b1c40c175ce1e98285 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Wed, 28 Dec 2022 14:41:27 +0100
Subject: [PATCH 2/5] WebAssembly: don't append `--export` for functions

No longer automatically append the `--export` flag for each exported
function unconditionally. This was essentially a hack to prevent
binary bloat caused by compiler-rt symbols being always included in
the final binary as they were exported and therefore not garbage-
collected. This is no longer needed as we now support the ability to
set the visibility of exports.
This essentially reverts 6d951aff7e32b1b0252d341e66517a9a9ee98a2d
---
 src/Compilation.zig |  9 ---------
 src/link/Wasm.zig   | 31 ++++++-------------------------
 2 files changed, 6 insertions(+), 34 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index ab91e3cbb3d6..5b80e5c7a77b 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -181,10 +181,6 @@ emit_docs: ?EmitLoc,
 work_queue_wait_group: WaitGroup = .{},
 astgen_wait_group: WaitGroup = .{},
 
-/// Exported symbol names. This is only for when the target is wasm.
-/// TODO: Remove this when Stage2 becomes the default compiler as it will already have this information.
-export_symbol_names: std.ArrayListUnmanaged([]const u8) = .{},
-
 pub const default_stack_protector_buffer_size = 4;
 pub const SemaError = Module.SemaError;
 
@@ -2168,11 +2164,6 @@ pub fn destroy(self: *Compilation) void {
     self.cache_parent.manifest_dir.close();
     if (self.owned_link_dir) |*dir| dir.close();
 
-    for (self.export_symbol_names.items) |symbol_name| {
-        gpa.free(symbol_name);
-    }
-    self.export_symbol_names.deinit(gpa);
-
     // This destroys `self`.
     self.arena_state.promote(gpa).deinit();
 }
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 1f929da150d5..7bc09c137caa 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -3406,39 +3406,14 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             try argv.append("--stack-first");
         }
 
-        var auto_export_symbols = true;
         // Users are allowed to specify which symbols they want to export to the wasm host.
         for (wasm.base.options.export_symbol_names) |symbol_name| {
             const arg = try std.fmt.allocPrint(arena, "--export={s}", .{symbol_name});
             try argv.append(arg);
-            auto_export_symbols = false;
         }
 
         if (wasm.base.options.rdynamic) {
             try argv.append("--export-dynamic");
-            auto_export_symbols = false;
-        }
-
-        if (auto_export_symbols) {
-            if (wasm.base.options.module) |mod| {
-                // when we use stage1, we use the exports that stage1 provided us.
-                // For stage2, we can directly retrieve them from the module.
-                const skip_export_non_fn = target.os.tag == .wasi and
-                    wasm.base.options.wasi_exec_model == .command;
-                for (mod.decl_exports.values()) |exports| {
-                    for (exports.items) |exprt| {
-                        const exported_decl = mod.declPtr(exprt.exported_decl);
-                        if (skip_export_non_fn and exported_decl.ty.zigTypeTag() != .Fn) {
-                            // skip exporting symbols when we're building a WASI command
-                            // and the symbol is not a function
-                            continue;
-                        }
-                        const symbol_name = exported_decl.name;
-                        const arg = try std.fmt.allocPrint(arena, "--export={s}", .{symbol_name});
-                        try argv.append(arg);
-                    }
-                }
-            }
         }
 
         if (wasm.base.options.entry) |entry| {
@@ -3457,6 +3432,12 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             if (wasm.base.options.wasi_exec_model == .reactor) {
                 // Reactor execution model does not have _start so lld doesn't look for it.
                 try argv.append("--no-entry");
+                // Make sure "_initialize" and other used-defined functions are exported if this is WASI reactor.
+                // If rdynamic is true, it will already be appended, so only verify if the user did not specify
+                // the flag in which case, we ensure `--export-dynamic` is called.
+                if (!wasm.base.options.rdynamic) {
+                    try argv.append("--export-dynamic");
+                }
             }
         } else if (wasm.base.options.entry == null) {
             try argv.append("--no-entry"); // So lld doesn't look for _start.

From 30f2bb8464bdae0af4920752aecaf61a3319b881 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Wed, 28 Dec 2022 14:57:17 +0100
Subject: [PATCH 3/5] compiler-rt: Set the symbol visibility

When we're compiling compiler_rt for any WebAssembly target, we do
not want to expose all the compiler-rt functions to the host runtime.
By setting the visibility of all exports to `hidden`, we allow the
linker to resolve the symbols during linktime, while not expose the
functions to the host runtime. This also means the linker can
properly garbage collect any compiler-rt function that does not get
resolved. The symbol visibility for all target remains the same as
before: `default`.
---
 lib/compiler_rt/absvdi2.zig     |   2 +-
 lib/compiler_rt/absvsi2.zig     |   2 +-
 lib/compiler_rt/absvti2.zig     |   2 +-
 lib/compiler_rt/adddf3.zig      |   4 +-
 lib/compiler_rt/addhf3.zig      |   2 +-
 lib/compiler_rt/addo.zig        |   8 +--
 lib/compiler_rt/addsf3.zig      |   4 +-
 lib/compiler_rt/addtf3.zig      |   6 +-
 lib/compiler_rt/addxf3.zig      |   2 +-
 lib/compiler_rt/arm.zig         |  40 +++++------
 lib/compiler_rt/atomics.zig     | 114 ++++++++++++++++----------------
 lib/compiler_rt/aulldiv.zig     |   4 +-
 lib/compiler_rt/aullrem.zig     |   4 +-
 lib/compiler_rt/bcmp.zig        |   2 +-
 lib/compiler_rt/bswap.zig       |   6 +-
 lib/compiler_rt/ceil.zig        |  14 ++--
 lib/compiler_rt/cmp.zig         |  12 ++--
 lib/compiler_rt/cmpdf2.zig      |  16 ++---
 lib/compiler_rt/cmphf2.zig      |  10 +--
 lib/compiler_rt/cmpsf2.zig      |  16 ++---
 lib/compiler_rt/cmptf2.zig      |  32 ++++-----
 lib/compiler_rt/cmpxf2.zig      |  10 +--
 lib/compiler_rt/common.zig      |   4 ++
 lib/compiler_rt/cos.zig         |  14 ++--
 lib/compiler_rt/count0bits.zig  |  18 ++---
 lib/compiler_rt/divdc3.zig      |   2 +-
 lib/compiler_rt/divdf3.zig      |   4 +-
 lib/compiler_rt/divhc3.zig      |   2 +-
 lib/compiler_rt/divhf3.zig      |   2 +-
 lib/compiler_rt/divsc3.zig      |   2 +-
 lib/compiler_rt/divsf3.zig      |   4 +-
 lib/compiler_rt/divtc3.zig      |   2 +-
 lib/compiler_rt/divtf3.zig      |   6 +-
 lib/compiler_rt/divti3.zig      |   8 +--
 lib/compiler_rt/divxc3.zig      |   2 +-
 lib/compiler_rt/divxf3.zig      |   2 +-
 lib/compiler_rt/emutls.zig      |   2 +-
 lib/compiler_rt/exp.zig         |  14 ++--
 lib/compiler_rt/exp2.zig        |  14 ++--
 lib/compiler_rt/extenddftf2.zig |   6 +-
 lib/compiler_rt/extenddfxf2.zig |   2 +-
 lib/compiler_rt/extendhfdf2.zig |   2 +-
 lib/compiler_rt/extendhfsf2.zig |   6 +-
 lib/compiler_rt/extendhftf2.zig |   2 +-
 lib/compiler_rt/extendhfxf2.zig |   2 +-
 lib/compiler_rt/extendsfdf2.zig |   4 +-
 lib/compiler_rt/extendsftf2.zig |   6 +-
 lib/compiler_rt/extendsfxf2.zig |   2 +-
 lib/compiler_rt/extendxftf2.zig |   2 +-
 lib/compiler_rt/fabs.zig        |  14 ++--
 lib/compiler_rt/fixdfdi.zig     |   4 +-
 lib/compiler_rt/fixdfsi.zig     |   4 +-
 lib/compiler_rt/fixdfti.zig     |   4 +-
 lib/compiler_rt/fixhfdi.zig     |   2 +-
 lib/compiler_rt/fixhfsi.zig     |   2 +-
 lib/compiler_rt/fixhfti.zig     |   4 +-
 lib/compiler_rt/fixsfdi.zig     |   4 +-
 lib/compiler_rt/fixsfsi.zig     |   4 +-
 lib/compiler_rt/fixsfti.zig     |   4 +-
 lib/compiler_rt/fixtfdi.zig     |   6 +-
 lib/compiler_rt/fixtfsi.zig     |   6 +-
 lib/compiler_rt/fixtfti.zig     |   4 +-
 lib/compiler_rt/fixunsdfdi.zig  |   4 +-
 lib/compiler_rt/fixunsdfsi.zig  |   4 +-
 lib/compiler_rt/fixunsdfti.zig  |   4 +-
 lib/compiler_rt/fixunshfdi.zig  |   2 +-
 lib/compiler_rt/fixunshfsi.zig  |   2 +-
 lib/compiler_rt/fixunshfti.zig  |   4 +-
 lib/compiler_rt/fixunssfdi.zig  |   4 +-
 lib/compiler_rt/fixunssfsi.zig  |   4 +-
 lib/compiler_rt/fixunssfti.zig  |   4 +-
 lib/compiler_rt/fixunstfdi.zig  |   6 +-
 lib/compiler_rt/fixunstfsi.zig  |   6 +-
 lib/compiler_rt/fixunstfti.zig  |   4 +-
 lib/compiler_rt/fixunsxfdi.zig  |   2 +-
 lib/compiler_rt/fixunsxfsi.zig  |   2 +-
 lib/compiler_rt/fixunsxfti.zig  |   4 +-
 lib/compiler_rt/fixxfdi.zig     |   2 +-
 lib/compiler_rt/fixxfsi.zig     |   2 +-
 lib/compiler_rt/fixxfti.zig     |   4 +-
 lib/compiler_rt/floatdidf.zig   |   4 +-
 lib/compiler_rt/floatdihf.zig   |   2 +-
 lib/compiler_rt/floatdisf.zig   |   4 +-
 lib/compiler_rt/floatditf.zig   |   6 +-
 lib/compiler_rt/floatdixf.zig   |   2 +-
 lib/compiler_rt/floatsidf.zig   |   4 +-
 lib/compiler_rt/floatsihf.zig   |   2 +-
 lib/compiler_rt/floatsisf.zig   |   4 +-
 lib/compiler_rt/floatsitf.zig   |   6 +-
 lib/compiler_rt/floatsixf.zig   |   2 +-
 lib/compiler_rt/floattidf.zig   |   4 +-
 lib/compiler_rt/floattihf.zig   |   4 +-
 lib/compiler_rt/floattisf.zig   |   4 +-
 lib/compiler_rt/floattitf.zig   |   4 +-
 lib/compiler_rt/floattixf.zig   |   4 +-
 lib/compiler_rt/floatundidf.zig |   4 +-
 lib/compiler_rt/floatundihf.zig |   2 +-
 lib/compiler_rt/floatundisf.zig |   4 +-
 lib/compiler_rt/floatunditf.zig |   6 +-
 lib/compiler_rt/floatundixf.zig |   2 +-
 lib/compiler_rt/floatunsidf.zig |   4 +-
 lib/compiler_rt/floatunsihf.zig |   2 +-
 lib/compiler_rt/floatunsisf.zig |   4 +-
 lib/compiler_rt/floatunsitf.zig |   6 +-
 lib/compiler_rt/floatunsixf.zig |   2 +-
 lib/compiler_rt/floatuntidf.zig |   4 +-
 lib/compiler_rt/floatuntihf.zig |   4 +-
 lib/compiler_rt/floatuntisf.zig |   4 +-
 lib/compiler_rt/floatuntitf.zig |   6 +-
 lib/compiler_rt/floatuntixf.zig |   4 +-
 lib/compiler_rt/floor.zig       |  14 ++--
 lib/compiler_rt/fma.zig         |  14 ++--
 lib/compiler_rt/fmax.zig        |  14 ++--
 lib/compiler_rt/fmin.zig        |  14 ++--
 lib/compiler_rt/fmod.zig        |  14 ++--
 lib/compiler_rt/gedf2.zig       |   8 +--
 lib/compiler_rt/gehf2.zig       |   4 +-
 lib/compiler_rt/gesf2.zig       |   8 +--
 lib/compiler_rt/getf2.zig       |   8 +--
 lib/compiler_rt/gexf2.zig       |   4 +-
 lib/compiler_rt/int.zig         |  30 ++++-----
 lib/compiler_rt/log.zig         |  14 ++--
 lib/compiler_rt/log10.zig       |  14 ++--
 lib/compiler_rt/log2.zig        |  14 ++--
 lib/compiler_rt/memcmp.zig      |   2 +-
 lib/compiler_rt/memcpy.zig      |   2 +-
 lib/compiler_rt/memmove.zig     |   2 +-
 lib/compiler_rt/memset.zig      |   4 +-
 lib/compiler_rt/modti3.zig      |   4 +-
 lib/compiler_rt/muldc3.zig      |   2 +-
 lib/compiler_rt/muldf3.zig      |   4 +-
 lib/compiler_rt/muldi3.zig      |   4 +-
 lib/compiler_rt/mulhc3.zig      |   2 +-
 lib/compiler_rt/mulhf3.zig      |   2 +-
 lib/compiler_rt/mulo.zig        |   6 +-
 lib/compiler_rt/mulsc3.zig      |   2 +-
 lib/compiler_rt/mulsf3.zig      |   4 +-
 lib/compiler_rt/multc3.zig      |   2 +-
 lib/compiler_rt/multf3.zig      |   6 +-
 lib/compiler_rt/multi3.zig      |   4 +-
 lib/compiler_rt/mulxc3.zig      |   2 +-
 lib/compiler_rt/mulxf3.zig      |   2 +-
 lib/compiler_rt/negXi2.zig      |   6 +-
 lib/compiler_rt/negdf2.zig      |   4 +-
 lib/compiler_rt/neghf2.zig      |   2 +-
 lib/compiler_rt/negsf2.zig      |   4 +-
 lib/compiler_rt/negtf2.zig      |   2 +-
 lib/compiler_rt/negv.zig        |   6 +-
 lib/compiler_rt/negxf2.zig      |   2 +-
 lib/compiler_rt/parity.zig      |   6 +-
 lib/compiler_rt/popcount.zig    |   6 +-
 lib/compiler_rt/round.zig       |  14 ++--
 lib/compiler_rt/shift.zig       |  18 ++---
 lib/compiler_rt/sin.zig         |  14 ++--
 lib/compiler_rt/sincos.zig      |  14 ++--
 lib/compiler_rt/sqrt.zig        |  14 ++--
 lib/compiler_rt/subdf3.zig      |   4 +-
 lib/compiler_rt/subhf3.zig      |   2 +-
 lib/compiler_rt/subo.zig        |   6 +-
 lib/compiler_rt/subsf3.zig      |   4 +-
 lib/compiler_rt/subtf3.zig      |   6 +-
 lib/compiler_rt/subxf3.zig      |   2 +-
 lib/compiler_rt/tan.zig         |  14 ++--
 lib/compiler_rt/trunc.zig       |  14 ++--
 lib/compiler_rt/truncdfhf2.zig  |   4 +-
 lib/compiler_rt/truncdfsf2.zig  |   4 +-
 lib/compiler_rt/truncsfhf2.zig  |   6 +-
 lib/compiler_rt/trunctfdf2.zig  |   6 +-
 lib/compiler_rt/trunctfhf2.zig  |   2 +-
 lib/compiler_rt/trunctfsf2.zig  |   6 +-
 lib/compiler_rt/trunctfxf2.zig  |   2 +-
 lib/compiler_rt/truncxfdf2.zig  |   2 +-
 lib/compiler_rt/truncxfhf2.zig  |   2 +-
 lib/compiler_rt/truncxfsf2.zig  |   2 +-
 lib/compiler_rt/udivmodei4.zig  |   4 +-
 lib/compiler_rt/udivmodti4.zig  |   4 +-
 lib/compiler_rt/udivti3.zig     |   4 +-
 lib/compiler_rt/umodti3.zig     |   4 +-
 lib/compiler_rt/unorddf2.zig    |   4 +-
 lib/compiler_rt/unordhf2.zig    |   2 +-
 lib/compiler_rt/unordsf2.zig    |   4 +-
 lib/compiler_rt/unordtf2.zig    |   4 +-
 lib/compiler_rt/unordxf2.zig    |   2 +-
 183 files changed, 578 insertions(+), 572 deletions(-)

diff --git a/lib/compiler_rt/absvdi2.zig b/lib/compiler_rt/absvdi2.zig
index 7ebf561ae5aa..14cd1d83932a 100644
--- a/lib/compiler_rt/absvdi2.zig
+++ b/lib/compiler_rt/absvdi2.zig
@@ -4,7 +4,7 @@ const absv = @import("./absv.zig").absv;
 pub const panic = common.panic;
 
 comptime {
-    @export(__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage });
+    @export(__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __absvdi2(a: i64) callconv(.C) i64 {
diff --git a/lib/compiler_rt/absvsi2.zig b/lib/compiler_rt/absvsi2.zig
index 664925f8f984..9ca9297c5627 100644
--- a/lib/compiler_rt/absvsi2.zig
+++ b/lib/compiler_rt/absvsi2.zig
@@ -4,7 +4,7 @@ const absv = @import("./absv.zig").absv;
 pub const panic = common.panic;
 
 comptime {
-    @export(__absvsi2, .{ .name = "__absvsi2", .linkage = common.linkage });
+    @export(__absvsi2, .{ .name = "__absvsi2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __absvsi2(a: i32) callconv(.C) i32 {
diff --git a/lib/compiler_rt/absvti2.zig b/lib/compiler_rt/absvti2.zig
index f7d0f796b0b5..f866f4c2c1e4 100644
--- a/lib/compiler_rt/absvti2.zig
+++ b/lib/compiler_rt/absvti2.zig
@@ -4,7 +4,7 @@ const absv = @import("./absv.zig").absv;
 pub const panic = common.panic;
 
 comptime {
-    @export(__absvti2, .{ .name = "__absvti2", .linkage = common.linkage });
+    @export(__absvti2, .{ .name = "__absvti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __absvti2(a: i128) callconv(.C) i128 {
diff --git a/lib/compiler_rt/adddf3.zig b/lib/compiler_rt/adddf3.zig
index 1b511f78a4e9..10ae9c328a82 100644
--- a/lib/compiler_rt/adddf3.zig
+++ b/lib/compiler_rt/adddf3.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = common.linkage });
+        @export(__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__adddf3, .{ .name = "__adddf3", .linkage = common.linkage });
+        @export(__adddf3, .{ .name = "__adddf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/addhf3.zig b/lib/compiler_rt/addhf3.zig
index 12086aef38e7..013c2ea714b5 100644
--- a/lib/compiler_rt/addhf3.zig
+++ b/lib/compiler_rt/addhf3.zig
@@ -4,7 +4,7 @@ const addf3 = @import("./addf3.zig").addf3;
 pub const panic = common.panic;
 
 comptime {
-    @export(__addhf3, .{ .name = "__addhf3", .linkage = common.linkage });
+    @export(__addhf3, .{ .name = "__addhf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __addhf3(a: f16, b: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/addo.zig b/lib/compiler_rt/addo.zig
index d14fe3671089..5248dfb8b86b 100644
--- a/lib/compiler_rt/addo.zig
+++ b/lib/compiler_rt/addo.zig
@@ -1,13 +1,13 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const is_test = builtin.is_test;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
+const common = @import("./common.zig");
 pub const panic = @import("common.zig").panic;
 
 comptime {
-    @export(__addosi4, .{ .name = "__addosi4", .linkage = linkage });
-    @export(__addodi4, .{ .name = "__addodi4", .linkage = linkage });
-    @export(__addoti4, .{ .name = "__addoti4", .linkage = linkage });
+    @export(__addosi4, .{ .name = "__addosi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__addodi4, .{ .name = "__addodi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__addoti4, .{ .name = "__addoti4", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 // addo - add overflow
diff --git a/lib/compiler_rt/addsf3.zig b/lib/compiler_rt/addsf3.zig
index 83f8285371bc..59e96da432f0 100644
--- a/lib/compiler_rt/addsf3.zig
+++ b/lib/compiler_rt/addsf3.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = common.linkage });
+        @export(__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__addsf3, .{ .name = "__addsf3", .linkage = common.linkage });
+        @export(__addsf3, .{ .name = "__addsf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/addtf3.zig b/lib/compiler_rt/addtf3.zig
index 15c450e193d5..e9a077fad51a 100644
--- a/lib/compiler_rt/addtf3.zig
+++ b/lib/compiler_rt/addtf3.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__addtf3, .{ .name = "__addkf3", .linkage = common.linkage });
+        @export(__addtf3, .{ .name = "__addkf3", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_add, .{ .name = "_Qp_add", .linkage = common.linkage });
+        @export(_Qp_add, .{ .name = "_Qp_add", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__addtf3, .{ .name = "__addtf3", .linkage = common.linkage });
+    @export(__addtf3, .{ .name = "__addtf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __addtf3(a: f128, b: f128) callconv(.C) f128 {
diff --git a/lib/compiler_rt/addxf3.zig b/lib/compiler_rt/addxf3.zig
index 72cf95563235..babb11ab8013 100644
--- a/lib/compiler_rt/addxf3.zig
+++ b/lib/compiler_rt/addxf3.zig
@@ -4,7 +4,7 @@ const addf3 = @import("./addf3.zig").addf3;
 pub const panic = common.panic;
 
 comptime {
-    @export(__addxf3, .{ .name = "__addxf3", .linkage = common.linkage });
+    @export(__addxf3, .{ .name = "__addxf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __addxf3(a: f80, b: f80) callconv(.C) f80 {
diff --git a/lib/compiler_rt/arm.zig b/lib/compiler_rt/arm.zig
index 145d3992f79e..27667d3b6095 100644
--- a/lib/compiler_rt/arm.zig
+++ b/lib/compiler_rt/arm.zig
@@ -9,34 +9,34 @@ pub const panic = common.panic;
 comptime {
     if (!builtin.is_test) {
         if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_unwind_cpp_pr0, .{ .name = "__aeabi_unwind_cpp_pr0", .linkage = common.linkage });
-            @export(__aeabi_unwind_cpp_pr1, .{ .name = "__aeabi_unwind_cpp_pr1", .linkage = common.linkage });
-            @export(__aeabi_unwind_cpp_pr2, .{ .name = "__aeabi_unwind_cpp_pr2", .linkage = common.linkage });
+            @export(__aeabi_unwind_cpp_pr0, .{ .name = "__aeabi_unwind_cpp_pr0", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_unwind_cpp_pr1, .{ .name = "__aeabi_unwind_cpp_pr1", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_unwind_cpp_pr2, .{ .name = "__aeabi_unwind_cpp_pr2", .linkage = common.linkage, .visibility = common.visibility });
 
-            @export(__aeabi_ldivmod, .{ .name = "__aeabi_ldivmod", .linkage = common.linkage });
-            @export(__aeabi_uldivmod, .{ .name = "__aeabi_uldivmod", .linkage = common.linkage });
+            @export(__aeabi_ldivmod, .{ .name = "__aeabi_ldivmod", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_uldivmod, .{ .name = "__aeabi_uldivmod", .linkage = common.linkage, .visibility = common.visibility });
 
-            @export(__aeabi_idivmod, .{ .name = "__aeabi_idivmod", .linkage = common.linkage });
-            @export(__aeabi_uidivmod, .{ .name = "__aeabi_uidivmod", .linkage = common.linkage });
+            @export(__aeabi_idivmod, .{ .name = "__aeabi_idivmod", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_uidivmod, .{ .name = "__aeabi_uidivmod", .linkage = common.linkage, .visibility = common.visibility });
 
-            @export(__aeabi_memcpy, .{ .name = "__aeabi_memcpy", .linkage = common.linkage });
-            @export(__aeabi_memcpy4, .{ .name = "__aeabi_memcpy4", .linkage = common.linkage });
-            @export(__aeabi_memcpy8, .{ .name = "__aeabi_memcpy8", .linkage = common.linkage });
+            @export(__aeabi_memcpy, .{ .name = "__aeabi_memcpy", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memcpy4, .{ .name = "__aeabi_memcpy4", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memcpy8, .{ .name = "__aeabi_memcpy8", .linkage = common.linkage, .visibility = common.visibility });
 
-            @export(__aeabi_memmove, .{ .name = "__aeabi_memmove", .linkage = common.linkage });
-            @export(__aeabi_memmove4, .{ .name = "__aeabi_memmove4", .linkage = common.linkage });
-            @export(__aeabi_memmove8, .{ .name = "__aeabi_memmove8", .linkage = common.linkage });
+            @export(__aeabi_memmove, .{ .name = "__aeabi_memmove", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memmove4, .{ .name = "__aeabi_memmove4", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memmove8, .{ .name = "__aeabi_memmove8", .linkage = common.linkage, .visibility = common.visibility });
 
-            @export(__aeabi_memset, .{ .name = "__aeabi_memset", .linkage = common.linkage });
-            @export(__aeabi_memset4, .{ .name = "__aeabi_memset4", .linkage = common.linkage });
-            @export(__aeabi_memset8, .{ .name = "__aeabi_memset8", .linkage = common.linkage });
+            @export(__aeabi_memset, .{ .name = "__aeabi_memset", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memset4, .{ .name = "__aeabi_memset4", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memset8, .{ .name = "__aeabi_memset8", .linkage = common.linkage, .visibility = common.visibility });
 
-            @export(__aeabi_memclr, .{ .name = "__aeabi_memclr", .linkage = common.linkage });
-            @export(__aeabi_memclr4, .{ .name = "__aeabi_memclr4", .linkage = common.linkage });
-            @export(__aeabi_memclr8, .{ .name = "__aeabi_memclr8", .linkage = common.linkage });
+            @export(__aeabi_memclr, .{ .name = "__aeabi_memclr", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memclr4, .{ .name = "__aeabi_memclr4", .linkage = common.linkage, .visibility = common.visibility });
+            @export(__aeabi_memclr8, .{ .name = "__aeabi_memclr8", .linkage = common.linkage, .visibility = common.visibility });
 
             if (builtin.os.tag == .linux) {
-                @export(__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = common.linkage });
+                @export(__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = common.linkage, .visibility = common.visibility });
             }
         }
     }
diff --git a/lib/compiler_rt/atomics.zig b/lib/compiler_rt/atomics.zig
index 13ca3a719772..73bf3fa03ba0 100644
--- a/lib/compiler_rt/atomics.zig
+++ b/lib/compiler_rt/atomics.zig
@@ -1,9 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const common = @import("./common.zig");
 const cpu = builtin.cpu;
 const arch = cpu.arch;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
+const linkage = common.linkage;
+const visibility = common.visibility;
+pub const panic = common.panic;
 
 // This parameter is true iff the target architecture supports the bare minimum
 // to implement the atomic load/store intrinsics.
@@ -454,59 +456,59 @@ fn __atomic_fetch_nand_8(ptr: *u64, val: u64, model: i32) callconv(.C) u64 {
 
 comptime {
     if (supports_atomic_ops and builtin.object_format != .c) {
-        @export(__atomic_load, .{ .name = "__atomic_load", .linkage = linkage });
-        @export(__atomic_store, .{ .name = "__atomic_store", .linkage = linkage });
-        @export(__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage });
-        @export(__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage });
-
-        @export(__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage });
-        @export(__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage });
-        @export(__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage });
-        @export(__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage });
-
-        @export(__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage });
-        @export(__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage });
-        @export(__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage });
-        @export(__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage });
-
-        @export(__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage });
-        @export(__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage });
-        @export(__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage });
-        @export(__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage });
-
-        @export(__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage });
-        @export(__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage });
-        @export(__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage });
-        @export(__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage });
-
-        @export(__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage });
-        @export(__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage });
-        @export(__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage });
-        @export(__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage });
-
-        @export(__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage });
-        @export(__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage });
-        @export(__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage });
-        @export(__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage });
-
-        @export(__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage });
-        @export(__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage });
-        @export(__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage });
-        @export(__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage });
-
-        @export(__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage });
-        @export(__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage });
-        @export(__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage });
-        @export(__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage });
-
-        @export(__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage });
-        @export(__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage });
-        @export(__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage });
-        @export(__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage });
-
-        @export(__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage });
-        @export(__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage });
-        @export(__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage });
-        @export(__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage });
+        @export(__atomic_load, .{ .name = "__atomic_load", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store, .{ .name = "__atomic_store", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage, .visibility = visibility });
     }
 }
diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig
index 3443e6ca0921..6c7d90f948a4 100644
--- a/lib/compiler_rt/aulldiv.zig
+++ b/lib/compiler_rt/aulldiv.zig
@@ -9,8 +9,8 @@ pub const panic = common.panic;
 comptime {
     if (arch == .x86 and abi == .msvc) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
-        @export(_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage });
-        @export(_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage });
+        @export(_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/aullrem.zig b/lib/compiler_rt/aullrem.zig
index 6960e1ecebca..63a35e518f35 100644
--- a/lib/compiler_rt/aullrem.zig
+++ b/lib/compiler_rt/aullrem.zig
@@ -9,8 +9,8 @@ pub const panic = common.panic;
 comptime {
     if (arch == .x86 and abi == .msvc) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
-        @export(_allrem, .{ .name = "\x01__allrem", .linkage = common.linkage });
-        @export(_aullrem, .{ .name = "\x01__aullrem", .linkage = common.linkage });
+        @export(_allrem, .{ .name = "\x01__allrem", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_aullrem, .{ .name = "\x01__aullrem", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/bcmp.zig b/lib/compiler_rt/bcmp.zig
index add6858ffefc..bc8d43b48e89 100644
--- a/lib/compiler_rt/bcmp.zig
+++ b/lib/compiler_rt/bcmp.zig
@@ -2,7 +2,7 @@ const std = @import("std");
 const common = @import("./common.zig");
 
 comptime {
-    @export(bcmp, .{ .name = "bcmp", .linkage = common.linkage });
+    @export(bcmp, .{ .name = "bcmp", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn bcmp(vl: [*]allowzero const u8, vr: [*]allowzero const u8, n: usize) callconv(.C) c_int {
diff --git a/lib/compiler_rt/bswap.zig b/lib/compiler_rt/bswap.zig
index 9f7d2cb879f8..ed330810f0ce 100644
--- a/lib/compiler_rt/bswap.zig
+++ b/lib/compiler_rt/bswap.zig
@@ -5,9 +5,9 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__bswapsi2, .{ .name = "__bswapsi2", .linkage = common.linkage });
-    @export(__bswapdi2, .{ .name = "__bswapdi2", .linkage = common.linkage });
-    @export(__bswapti2, .{ .name = "__bswapti2", .linkage = common.linkage });
+    @export(__bswapsi2, .{ .name = "__bswapsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__bswapdi2, .{ .name = "__bswapdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__bswapti2, .{ .name = "__bswapti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 // bswap - byteswap
diff --git a/lib/compiler_rt/ceil.zig b/lib/compiler_rt/ceil.zig
index 662254650104..2765ed9f741c 100644
--- a/lib/compiler_rt/ceil.zig
+++ b/lib/compiler_rt/ceil.zig
@@ -14,15 +14,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__ceilh, .{ .name = "__ceilh", .linkage = common.linkage });
-    @export(ceilf, .{ .name = "ceilf", .linkage = common.linkage });
-    @export(ceil, .{ .name = "ceil", .linkage = common.linkage });
-    @export(__ceilx, .{ .name = "__ceilx", .linkage = common.linkage });
+    @export(__ceilh, .{ .name = "__ceilh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(ceilf, .{ .name = "ceilf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(ceil, .{ .name = "ceil", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ceilx, .{ .name = "__ceilx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(ceilq, .{ .name = "ceilf128", .linkage = common.linkage });
+        @export(ceilq, .{ .name = "ceilf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(ceilq, .{ .name = "ceilq", .linkage = common.linkage });
-    @export(ceill, .{ .name = "ceill", .linkage = common.linkage });
+    @export(ceilq, .{ .name = "ceilq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(ceill, .{ .name = "ceill", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __ceilh(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/cmp.zig b/lib/compiler_rt/cmp.zig
index 8ff2c38cd497..cebc38c2ae48 100644
--- a/lib/compiler_rt/cmp.zig
+++ b/lib/compiler_rt/cmp.zig
@@ -6,12 +6,12 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__cmpsi2, .{ .name = "__cmpsi2", .linkage = common.linkage });
-    @export(__cmpdi2, .{ .name = "__cmpdi2", .linkage = common.linkage });
-    @export(__cmpti2, .{ .name = "__cmpti2", .linkage = common.linkage });
-    @export(__ucmpsi2, .{ .name = "__ucmpsi2", .linkage = common.linkage });
-    @export(__ucmpdi2, .{ .name = "__ucmpdi2", .linkage = common.linkage });
-    @export(__ucmpti2, .{ .name = "__ucmpti2", .linkage = common.linkage });
+    @export(__cmpsi2, .{ .name = "__cmpsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__cmpdi2, .{ .name = "__cmpdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__cmpti2, .{ .name = "__cmpti2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ucmpsi2, .{ .name = "__ucmpsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ucmpdi2, .{ .name = "__ucmpdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ucmpti2, .{ .name = "__ucmpti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 // cmp - signed compare
diff --git a/lib/compiler_rt/cmpdf2.zig b/lib/compiler_rt/cmpdf2.zig
index 67dbcd8b4d61..8a7b37c2c9f0 100644
--- a/lib/compiler_rt/cmpdf2.zig
+++ b/lib/compiler_rt/cmpdf2.zig
@@ -7,15 +7,15 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = common.linkage });
-        @export(__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = common.linkage });
-        @export(__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = common.linkage });
+        @export(__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__eqdf2, .{ .name = "__eqdf2", .linkage = common.linkage });
-        @export(__nedf2, .{ .name = "__nedf2", .linkage = common.linkage });
-        @export(__ledf2, .{ .name = "__ledf2", .linkage = common.linkage });
-        @export(__cmpdf2, .{ .name = "__cmpdf2", .linkage = common.linkage });
-        @export(__ltdf2, .{ .name = "__ltdf2", .linkage = common.linkage });
+        @export(__eqdf2, .{ .name = "__eqdf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__nedf2, .{ .name = "__nedf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__ledf2, .{ .name = "__ledf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__cmpdf2, .{ .name = "__cmpdf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__ltdf2, .{ .name = "__ltdf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/cmphf2.zig b/lib/compiler_rt/cmphf2.zig
index d5ee3f1daa15..d801b30ff6e3 100644
--- a/lib/compiler_rt/cmphf2.zig
+++ b/lib/compiler_rt/cmphf2.zig
@@ -6,11 +6,11 @@ const comparef = @import("./comparef.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__eqhf2, .{ .name = "__eqhf2", .linkage = common.linkage });
-    @export(__nehf2, .{ .name = "__nehf2", .linkage = common.linkage });
-    @export(__lehf2, .{ .name = "__lehf2", .linkage = common.linkage });
-    @export(__cmphf2, .{ .name = "__cmphf2", .linkage = common.linkage });
-    @export(__lthf2, .{ .name = "__lthf2", .linkage = common.linkage });
+    @export(__eqhf2, .{ .name = "__eqhf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__nehf2, .{ .name = "__nehf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__lehf2, .{ .name = "__lehf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__cmphf2, .{ .name = "__cmphf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__lthf2, .{ .name = "__lthf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 /// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
diff --git a/lib/compiler_rt/cmpsf2.zig b/lib/compiler_rt/cmpsf2.zig
index 1ac40ef6e2cb..35e250e8109f 100644
--- a/lib/compiler_rt/cmpsf2.zig
+++ b/lib/compiler_rt/cmpsf2.zig
@@ -7,15 +7,15 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fcmpeq, .{ .name = "__aeabi_fcmpeq", .linkage = common.linkage });
-        @export(__aeabi_fcmplt, .{ .name = "__aeabi_fcmplt", .linkage = common.linkage });
-        @export(__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = common.linkage });
+        @export(__aeabi_fcmpeq, .{ .name = "__aeabi_fcmpeq", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_fcmplt, .{ .name = "__aeabi_fcmplt", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__eqsf2, .{ .name = "__eqsf2", .linkage = common.linkage });
-        @export(__nesf2, .{ .name = "__nesf2", .linkage = common.linkage });
-        @export(__lesf2, .{ .name = "__lesf2", .linkage = common.linkage });
-        @export(__cmpsf2, .{ .name = "__cmpsf2", .linkage = common.linkage });
-        @export(__ltsf2, .{ .name = "__ltsf2", .linkage = common.linkage });
+        @export(__eqsf2, .{ .name = "__eqsf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__nesf2, .{ .name = "__nesf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__lesf2, .{ .name = "__lesf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__cmpsf2, .{ .name = "__cmpsf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__ltsf2, .{ .name = "__ltsf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig
index 98137e3dfcdb..bc53afc62531 100644
--- a/lib/compiler_rt/cmptf2.zig
+++ b/lib/compiler_rt/cmptf2.zig
@@ -7,24 +7,24 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__eqtf2, .{ .name = "__eqkf2", .linkage = common.linkage });
-        @export(__netf2, .{ .name = "__nekf2", .linkage = common.linkage });
-        @export(__lttf2, .{ .name = "__ltkf2", .linkage = common.linkage });
-        @export(__letf2, .{ .name = "__lekf2", .linkage = common.linkage });
+        @export(__eqtf2, .{ .name = "__eqkf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__netf2, .{ .name = "__nekf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__lttf2, .{ .name = "__ltkf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__letf2, .{ .name = "__lekf2", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = common.linkage });
-        @export(_Qp_feq, .{ .name = "_Qp_feq", .linkage = common.linkage });
-        @export(_Qp_fne, .{ .name = "_Qp_fne", .linkage = common.linkage });
-        @export(_Qp_flt, .{ .name = "_Qp_flt", .linkage = common.linkage });
-        @export(_Qp_fle, .{ .name = "_Qp_fle", .linkage = common.linkage });
-        @export(_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = common.linkage });
-        @export(_Qp_fge, .{ .name = "_Qp_fge", .linkage = common.linkage });
+        @export(_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_Qp_feq, .{ .name = "_Qp_feq", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_Qp_fne, .{ .name = "_Qp_fne", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_Qp_flt, .{ .name = "_Qp_flt", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_Qp_fle, .{ .name = "_Qp_fle", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = common.linkage, .visibility = common.visibility });
+        @export(_Qp_fge, .{ .name = "_Qp_fge", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage });
-    @export(__netf2, .{ .name = "__netf2", .linkage = common.linkage });
-    @export(__letf2, .{ .name = "__letf2", .linkage = common.linkage });
-    @export(__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage });
-    @export(__lttf2, .{ .name = "__lttf2", .linkage = common.linkage });
+    @export(__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__netf2, .{ .name = "__netf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__letf2, .{ .name = "__letf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__lttf2, .{ .name = "__lttf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 /// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
diff --git a/lib/compiler_rt/cmpxf2.zig b/lib/compiler_rt/cmpxf2.zig
index 7286316f99c7..75355775bbd7 100644
--- a/lib/compiler_rt/cmpxf2.zig
+++ b/lib/compiler_rt/cmpxf2.zig
@@ -6,11 +6,11 @@ const comparef = @import("./comparef.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__eqxf2, .{ .name = "__eqxf2", .linkage = common.linkage });
-    @export(__nexf2, .{ .name = "__nexf2", .linkage = common.linkage });
-    @export(__lexf2, .{ .name = "__lexf2", .linkage = common.linkage });
-    @export(__cmpxf2, .{ .name = "__cmpxf2", .linkage = common.linkage });
-    @export(__ltxf2, .{ .name = "__ltxf2", .linkage = common.linkage });
+    @export(__eqxf2, .{ .name = "__eqxf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__nexf2, .{ .name = "__nexf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__lexf2, .{ .name = "__lexf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__cmpxf2, .{ .name = "__cmpxf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ltxf2, .{ .name = "__ltxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 /// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
index f16ecf0e188a..40a770070dac 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -2,6 +2,10 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
+/// 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.isWasm()) .hidden else .default;
 pub const want_aeabi = switch (builtin.abi) {
     .eabi,
     .eabihf,
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index 664f6550a4ed..029b6c346a3d 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -12,15 +12,15 @@ const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 
 comptime {
-    @export(__cosh, .{ .name = "__cosh", .linkage = common.linkage });
-    @export(cosf, .{ .name = "cosf", .linkage = common.linkage });
-    @export(cos, .{ .name = "cos", .linkage = common.linkage });
-    @export(__cosx, .{ .name = "__cosx", .linkage = common.linkage });
+    @export(__cosh, .{ .name = "__cosh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(cosf, .{ .name = "cosf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(cos, .{ .name = "cos", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__cosx, .{ .name = "__cosx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(cosq, .{ .name = "cosf128", .linkage = common.linkage });
+        @export(cosq, .{ .name = "cosf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(cosq, .{ .name = "cosq", .linkage = common.linkage });
-    @export(cosl, .{ .name = "cosl", .linkage = common.linkage });
+    @export(cosq, .{ .name = "cosq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(cosl, .{ .name = "cosl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __cosh(a: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/count0bits.zig b/lib/compiler_rt/count0bits.zig
index d763e5c8a329..e1500d010267 100644
--- a/lib/compiler_rt/count0bits.zig
+++ b/lib/compiler_rt/count0bits.zig
@@ -6,15 +6,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__clzsi2, .{ .name = "__clzsi2", .linkage = common.linkage });
-    @export(__clzdi2, .{ .name = "__clzdi2", .linkage = common.linkage });
-    @export(__clzti2, .{ .name = "__clzti2", .linkage = common.linkage });
-    @export(__ctzsi2, .{ .name = "__ctzsi2", .linkage = common.linkage });
-    @export(__ctzdi2, .{ .name = "__ctzdi2", .linkage = common.linkage });
-    @export(__ctzti2, .{ .name = "__ctzti2", .linkage = common.linkage });
-    @export(__ffssi2, .{ .name = "__ffssi2", .linkage = common.linkage });
-    @export(__ffsdi2, .{ .name = "__ffsdi2", .linkage = common.linkage });
-    @export(__ffsti2, .{ .name = "__ffsti2", .linkage = common.linkage });
+    @export(__clzsi2, .{ .name = "__clzsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__clzdi2, .{ .name = "__clzdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__clzti2, .{ .name = "__clzti2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ctzsi2, .{ .name = "__ctzsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ctzdi2, .{ .name = "__ctzdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ctzti2, .{ .name = "__ctzti2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ffssi2, .{ .name = "__ffssi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ffsdi2, .{ .name = "__ffsdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ffsti2, .{ .name = "__ffsti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 // clz - count leading zeroes
diff --git a/lib/compiler_rt/divdc3.zig b/lib/compiler_rt/divdc3.zig
index 8aad682e6196..ddcb0b83ea49 100644
--- a/lib/compiler_rt/divdc3.zig
+++ b/lib/compiler_rt/divdc3.zig
@@ -4,7 +4,7 @@ const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__divdc3, .{ .name = "__divdc3", .linkage = common.linkage });
+        @export(__divdc3, .{ .name = "__divdc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divdf3.zig b/lib/compiler_rt/divdf3.zig
index dd22f4836cc4..2f83d312dcc1 100644
--- a/lib/compiler_rt/divdf3.zig
+++ b/lib/compiler_rt/divdf3.zig
@@ -15,9 +15,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = common.linkage });
+        @export(__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__divdf3, .{ .name = "__divdf3", .linkage = common.linkage });
+        @export(__divdf3, .{ .name = "__divdf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divhc3.zig b/lib/compiler_rt/divhc3.zig
index 3de896759332..7e9bfeb0fff8 100644
--- a/lib/compiler_rt/divhc3.zig
+++ b/lib/compiler_rt/divhc3.zig
@@ -4,7 +4,7 @@ const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__divhc3, .{ .name = "__divhc3", .linkage = common.linkage });
+        @export(__divhc3, .{ .name = "__divhc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divhf3.zig b/lib/compiler_rt/divhf3.zig
index ad73a5ddb271..6bb607bef935 100644
--- a/lib/compiler_rt/divhf3.zig
+++ b/lib/compiler_rt/divhf3.zig
@@ -2,7 +2,7 @@ const common = @import("common.zig");
 const divsf3 = @import("./divsf3.zig");
 
 comptime {
-    @export(__divhf3, .{ .name = "__divhf3", .linkage = common.linkage });
+    @export(__divhf3, .{ .name = "__divhf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __divhf3(a: f16, b: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/divsc3.zig b/lib/compiler_rt/divsc3.zig
index c9e0c0cbf567..20cdc56a0919 100644
--- a/lib/compiler_rt/divsc3.zig
+++ b/lib/compiler_rt/divsc3.zig
@@ -4,7 +4,7 @@ const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__divsc3, .{ .name = "__divsc3", .linkage = common.linkage });
+        @export(__divsc3, .{ .name = "__divsc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divsf3.zig b/lib/compiler_rt/divsf3.zig
index 13565f9b6424..5f051416104b 100644
--- a/lib/compiler_rt/divsf3.zig
+++ b/lib/compiler_rt/divsf3.zig
@@ -13,9 +13,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = common.linkage });
+        @export(__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__divsf3, .{ .name = "__divsf3", .linkage = common.linkage });
+        @export(__divsf3, .{ .name = "__divsf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divtc3.zig b/lib/compiler_rt/divtc3.zig
index e2382a1372be..d5b1d1205996 100644
--- a/lib/compiler_rt/divtc3.zig
+++ b/lib/compiler_rt/divtc3.zig
@@ -4,7 +4,7 @@ const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__divtc3, .{ .name = "__divtc3", .linkage = common.linkage });
+        @export(__divtc3, .{ .name = "__divtc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divtf3.zig b/lib/compiler_rt/divtf3.zig
index 736068e81977..511a9582a3bd 100644
--- a/lib/compiler_rt/divtf3.zig
+++ b/lib/compiler_rt/divtf3.zig
@@ -10,11 +10,11 @@ pub const panic = common.panic;
 comptime {
     if (common.want_ppc_abi) {
         // TODO: why did this not error?
-        @export(__divtf3, .{ .name = "__divkf3", .linkage = common.linkage });
+        @export(__divtf3, .{ .name = "__divkf3", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_div, .{ .name = "_Qp_div", .linkage = common.linkage });
+        @export(_Qp_div, .{ .name = "_Qp_div", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__divtf3, .{ .name = "__divtf3", .linkage = common.linkage });
+    @export(__divtf3, .{ .name = "__divtf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __divtf3(a: f128, b: f128) callconv(.C) f128 {
diff --git a/lib/compiler_rt/divti3.zig b/lib/compiler_rt/divti3.zig
index 6899cd323f59..cd38d7a93e85 100644
--- a/lib/compiler_rt/divti3.zig
+++ b/lib/compiler_rt/divti3.zig
@@ -10,20 +10,20 @@ comptime {
     if (builtin.os.tag == .windows) {
         switch (arch) {
             .x86 => {
-                @export(__divti3, .{ .name = "__divti3", .linkage = common.linkage });
+                @export(__divti3, .{ .name = "__divti3", .linkage = common.linkage, .visibility = common.visibility });
             },
             .x86_64 => {
                 // The "ti" functions must use Vector(2, u64) parameter types to adhere to the ABI
                 // that LLVM expects compiler-rt to have.
-                @export(__divti3_windows_x86_64, .{ .name = "__divti3", .linkage = common.linkage });
+                @export(__divti3_windows_x86_64, .{ .name = "__divti3", .linkage = common.linkage, .visibility = common.visibility });
             },
             else => {},
         }
         if (arch.isAARCH64()) {
-            @export(__divti3, .{ .name = "__divti3", .linkage = common.linkage });
+            @export(__divti3, .{ .name = "__divti3", .linkage = common.linkage, .visibility = common.visibility });
         }
     } else {
-        @export(__divti3, .{ .name = "__divti3", .linkage = common.linkage });
+        @export(__divti3, .{ .name = "__divti3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divxc3.zig b/lib/compiler_rt/divxc3.zig
index c6ed5a210c6e..177e26cfd847 100644
--- a/lib/compiler_rt/divxc3.zig
+++ b/lib/compiler_rt/divxc3.zig
@@ -4,7 +4,7 @@ const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__divxc3, .{ .name = "__divxc3", .linkage = common.linkage });
+        @export(__divxc3, .{ .name = "__divxc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/divxf3.zig b/lib/compiler_rt/divxf3.zig
index 2282c2129902..18fd20b726bc 100644
--- a/lib/compiler_rt/divxf3.zig
+++ b/lib/compiler_rt/divxf3.zig
@@ -9,7 +9,7 @@ const wideMultiply = common.wideMultiply;
 pub const panic = common.panic;
 
 comptime {
-    @export(__divxf3, .{ .name = "__divxf3", .linkage = common.linkage });
+    @export(__divxf3, .{ .name = "__divxf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __divxf3(a: f80, b: f80) callconv(.C) f80 {
diff --git a/lib/compiler_rt/emutls.zig b/lib/compiler_rt/emutls.zig
index 57d495d8bd7d..4b37e6dcfc75 100644
--- a/lib/compiler_rt/emutls.zig
+++ b/lib/compiler_rt/emutls.zig
@@ -19,7 +19,7 @@ pub const panic = common.panic;
 
 comptime {
     if (builtin.link_libc and (builtin.abi == .android or builtin.os.tag == .openbsd)) {
-        @export(__emutls_get_address, .{ .name = "__emutls_get_address", .linkage = common.linkage });
+        @export(__emutls_get_address, .{ .name = "__emutls_get_address", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig
index 7dfac7328ca8..24d29ad0bba4 100644
--- a/lib/compiler_rt/exp.zig
+++ b/lib/compiler_rt/exp.zig
@@ -14,15 +14,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__exph, .{ .name = "__exph", .linkage = common.linkage });
-    @export(expf, .{ .name = "expf", .linkage = common.linkage });
-    @export(exp, .{ .name = "exp", .linkage = common.linkage });
-    @export(__expx, .{ .name = "__expx", .linkage = common.linkage });
+    @export(__exph, .{ .name = "__exph", .linkage = common.linkage, .visibility = common.visibility });
+    @export(expf, .{ .name = "expf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(exp, .{ .name = "exp", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__expx, .{ .name = "__expx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(expq, .{ .name = "expf128", .linkage = common.linkage });
+        @export(expq, .{ .name = "expf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(expq, .{ .name = "expq", .linkage = common.linkage });
-    @export(expl, .{ .name = "expl", .linkage = common.linkage });
+    @export(expq, .{ .name = "expq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(expl, .{ .name = "expl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __exph(a: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/exp2.zig b/lib/compiler_rt/exp2.zig
index daca339baecc..188236752244 100644
--- a/lib/compiler_rt/exp2.zig
+++ b/lib/compiler_rt/exp2.zig
@@ -14,15 +14,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__exp2h, .{ .name = "__exp2h", .linkage = common.linkage });
-    @export(exp2f, .{ .name = "exp2f", .linkage = common.linkage });
-    @export(exp2, .{ .name = "exp2", .linkage = common.linkage });
-    @export(__exp2x, .{ .name = "__exp2x", .linkage = common.linkage });
+    @export(__exp2h, .{ .name = "__exp2h", .linkage = common.linkage, .visibility = common.visibility });
+    @export(exp2f, .{ .name = "exp2f", .linkage = common.linkage, .visibility = common.visibility });
+    @export(exp2, .{ .name = "exp2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__exp2x, .{ .name = "__exp2x", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(exp2q, .{ .name = "exp2f128", .linkage = common.linkage });
+        @export(exp2q, .{ .name = "exp2f128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(exp2q, .{ .name = "exp2q", .linkage = common.linkage });
-    @export(exp2l, .{ .name = "exp2l", .linkage = common.linkage });
+    @export(exp2q, .{ .name = "exp2q", .linkage = common.linkage, .visibility = common.visibility });
+    @export(exp2l, .{ .name = "exp2l", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __exp2h(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/extenddftf2.zig b/lib/compiler_rt/extenddftf2.zig
index 300598753079..e7b2d8ed705b 100644
--- a/lib/compiler_rt/extenddftf2.zig
+++ b/lib/compiler_rt/extenddftf2.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__extenddftf2, .{ .name = "__extenddfkf2", .linkage = common.linkage });
+        @export(__extenddftf2, .{ .name = "__extenddfkf2", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = common.linkage });
+        @export(_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage });
+    @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __extenddftf2(a: f64) callconv(.C) f128 {
diff --git a/lib/compiler_rt/extenddfxf2.zig b/lib/compiler_rt/extenddfxf2.zig
index 380a7de4a431..c9e10d57ecec 100644
--- a/lib/compiler_rt/extenddfxf2.zig
+++ b/lib/compiler_rt/extenddfxf2.zig
@@ -4,7 +4,7 @@ const extend_f80 = @import("./extendf.zig").extend_f80;
 pub const panic = common.panic;
 
 comptime {
-    @export(__extenddfxf2, .{ .name = "__extenddfxf2", .linkage = common.linkage });
+    @export(__extenddfxf2, .{ .name = "__extenddfxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __extenddfxf2(a: f64) callconv(.C) f80 {
diff --git a/lib/compiler_rt/extendhfdf2.zig b/lib/compiler_rt/extendhfdf2.zig
index f7a94f58efe0..97311b104c6d 100644
--- a/lib/compiler_rt/extendhfdf2.zig
+++ b/lib/compiler_rt/extendhfdf2.zig
@@ -4,7 +4,7 @@ const extendf = @import("./extendf.zig").extendf;
 pub const panic = common.panic;
 
 comptime {
-    @export(__extendhfdf2, .{ .name = "__extendhfdf2", .linkage = common.linkage });
+    @export(__extendhfdf2, .{ .name = "__extendhfdf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __extendhfdf2(a: common.F16T) callconv(.C) f64 {
diff --git a/lib/compiler_rt/extendhfsf2.zig b/lib/compiler_rt/extendhfsf2.zig
index f019b42cb622..41d9282e8ae3 100644
--- a/lib/compiler_rt/extendhfsf2.zig
+++ b/lib/compiler_rt/extendhfsf2.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.gnu_f16_abi) {
-        @export(__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = common.linkage });
+        @export(__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_aeabi) {
-        @export(__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = common.linkage });
+        @export(__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = common.linkage });
+    @export(__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __extendhfsf2(a: common.F16T) callconv(.C) f32 {
diff --git a/lib/compiler_rt/extendhftf2.zig b/lib/compiler_rt/extendhftf2.zig
index 5d339fabce8c..2d6307af3506 100644
--- a/lib/compiler_rt/extendhftf2.zig
+++ b/lib/compiler_rt/extendhftf2.zig
@@ -4,7 +4,7 @@ const extendf = @import("./extendf.zig").extendf;
 pub const panic = common.panic;
 
 comptime {
-    @export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = common.linkage });
+    @export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __extendhftf2(a: common.F16T) callconv(.C) f128 {
diff --git a/lib/compiler_rt/extendhfxf2.zig b/lib/compiler_rt/extendhfxf2.zig
index e509f9657560..1f9c43328f20 100644
--- a/lib/compiler_rt/extendhfxf2.zig
+++ b/lib/compiler_rt/extendhfxf2.zig
@@ -4,7 +4,7 @@ const extend_f80 = @import("./extendf.zig").extend_f80;
 pub const panic = common.panic;
 
 comptime {
-    @export(__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = common.linkage });
+    @export(__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __extendhfxf2(a: common.F16T) callconv(.C) f80 {
diff --git a/lib/compiler_rt/extendsfdf2.zig b/lib/compiler_rt/extendsfdf2.zig
index 7fd69f6c2252..0a7ba8df531d 100644
--- a/lib/compiler_rt/extendsfdf2.zig
+++ b/lib/compiler_rt/extendsfdf2.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = common.linkage });
+        @export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = common.linkage });
+        @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/extendsftf2.zig b/lib/compiler_rt/extendsftf2.zig
index 68b07470423a..a74319745a3e 100644
--- a/lib/compiler_rt/extendsftf2.zig
+++ b/lib/compiler_rt/extendsftf2.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__extendsftf2, .{ .name = "__extendsfkf2", .linkage = common.linkage });
+        @export(__extendsftf2, .{ .name = "__extendsfkf2", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_stoq, .{ .name = "_Qp_stoq", .linkage = common.linkage });
+        @export(_Qp_stoq, .{ .name = "_Qp_stoq", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = common.linkage });
+    @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __extendsftf2(a: f32) callconv(.C) f128 {
diff --git a/lib/compiler_rt/extendsfxf2.zig b/lib/compiler_rt/extendsfxf2.zig
index 41bb5ace852a..938e65c1bd71 100644
--- a/lib/compiler_rt/extendsfxf2.zig
+++ b/lib/compiler_rt/extendsfxf2.zig
@@ -4,7 +4,7 @@ const extend_f80 = @import("./extendf.zig").extend_f80;
 pub const panic = common.panic;
 
 comptime {
-    @export(__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = common.linkage });
+    @export(__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __extendsfxf2(a: f32) callconv(.C) f80 {
diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig
index 077d51064643..c3243d3018b7 100644
--- a/lib/compiler_rt/extendxftf2.zig
+++ b/lib/compiler_rt/extendxftf2.zig
@@ -4,7 +4,7 @@ const common = @import("./common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__extendxftf2, .{ .name = "__extendxftf2", .linkage = common.linkage });
+    @export(__extendxftf2, .{ .name = "__extendxftf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __extendxftf2(a: f80) callconv(.C) f128 {
diff --git a/lib/compiler_rt/fabs.zig b/lib/compiler_rt/fabs.zig
index e9ce98bb7aa2..b38e15e593bb 100644
--- a/lib/compiler_rt/fabs.zig
+++ b/lib/compiler_rt/fabs.zig
@@ -6,15 +6,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__fabsh, .{ .name = "__fabsh", .linkage = common.linkage });
-    @export(fabsf, .{ .name = "fabsf", .linkage = common.linkage });
-    @export(fabs, .{ .name = "fabs", .linkage = common.linkage });
-    @export(__fabsx, .{ .name = "__fabsx", .linkage = common.linkage });
+    @export(__fabsh, .{ .name = "__fabsh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fabsf, .{ .name = "fabsf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fabs, .{ .name = "fabs", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__fabsx, .{ .name = "__fabsx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(fabsq, .{ .name = "fabsf128", .linkage = common.linkage });
+        @export(fabsq, .{ .name = "fabsf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(fabsq, .{ .name = "fabsq", .linkage = common.linkage });
-    @export(fabsl, .{ .name = "fabsl", .linkage = common.linkage });
+    @export(fabsq, .{ .name = "fabsq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fabsl, .{ .name = "fabsl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fabsh(a: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/fixdfdi.zig b/lib/compiler_rt/fixdfdi.zig
index 5935f2352416..0329b3cc13b0 100644
--- a/lib/compiler_rt/fixdfdi.zig
+++ b/lib/compiler_rt/fixdfdi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = common.linkage });
+        @export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = common.linkage });
+        @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixdfsi.zig b/lib/compiler_rt/fixdfsi.zig
index 983c84ccb141..74406171b4b5 100644
--- a/lib/compiler_rt/fixdfsi.zig
+++ b/lib/compiler_rt/fixdfsi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = common.linkage });
+        @export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = common.linkage });
+        @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig
index 532b27107208..ecb4e8912c97 100644
--- a/lib/compiler_rt/fixdfti.zig
+++ b/lib/compiler_rt/fixdfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixdfti_windows_x86_64, .{ .name = "__fixdfti", .linkage = common.linkage });
+        @export(__fixdfti_windows_x86_64, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage });
+        @export(__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixhfdi.zig b/lib/compiler_rt/fixhfdi.zig
index 28e871f495b1..3cb1186d7109 100644
--- a/lib/compiler_rt/fixhfdi.zig
+++ b/lib/compiler_rt/fixhfdi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixhfdi, .{ .name = "__fixhfdi", .linkage = common.linkage });
+    @export(__fixhfdi, .{ .name = "__fixhfdi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixhfdi(a: f16) callconv(.C) i64 {
diff --git a/lib/compiler_rt/fixhfsi.zig b/lib/compiler_rt/fixhfsi.zig
index 23440eea22e9..2f24649fb7b8 100644
--- a/lib/compiler_rt/fixhfsi.zig
+++ b/lib/compiler_rt/fixhfsi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixhfsi, .{ .name = "__fixhfsi", .linkage = common.linkage });
+    @export(__fixhfsi, .{ .name = "__fixhfsi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixhfsi(a: f16) callconv(.C) i32 {
diff --git a/lib/compiler_rt/fixhfti.zig b/lib/compiler_rt/fixhfti.zig
index b6774968ddc3..2865bcad2955 100644
--- a/lib/compiler_rt/fixhfti.zig
+++ b/lib/compiler_rt/fixhfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixhfti_windows_x86_64, .{ .name = "__fixhfti", .linkage = common.linkage });
+        @export(__fixhfti_windows_x86_64, .{ .name = "__fixhfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixhfti, .{ .name = "__fixhfti", .linkage = common.linkage });
+        @export(__fixhfti, .{ .name = "__fixhfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixsfdi.zig b/lib/compiler_rt/fixsfdi.zig
index 0c4fb7f3f60d..4bb63e676851 100644
--- a/lib/compiler_rt/fixsfdi.zig
+++ b/lib/compiler_rt/fixsfdi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage });
+        @export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage });
+        @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixsfsi.zig b/lib/compiler_rt/fixsfsi.zig
index f48e354cd270..55eb6e227614 100644
--- a/lib/compiler_rt/fixsfsi.zig
+++ b/lib/compiler_rt/fixsfsi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = common.linkage });
+        @export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = common.linkage });
+        @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixsfti.zig b/lib/compiler_rt/fixsfti.zig
index 5aa4068b6265..cd5e524b2041 100644
--- a/lib/compiler_rt/fixsfti.zig
+++ b/lib/compiler_rt/fixsfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixsfti_windows_x86_64, .{ .name = "__fixsfti", .linkage = common.linkage });
+        @export(__fixsfti_windows_x86_64, .{ .name = "__fixsfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixsfti, .{ .name = "__fixsfti", .linkage = common.linkage });
+        @export(__fixsfti, .{ .name = "__fixsfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixtfdi.zig b/lib/compiler_rt/fixtfdi.zig
index f9a32828f18c..bafcf6d83a87 100644
--- a/lib/compiler_rt/fixtfdi.zig
+++ b/lib/compiler_rt/fixtfdi.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixtfdi, .{ .name = "__fixkfdi", .linkage = common.linkage });
+        @export(__fixtfdi, .{ .name = "__fixkfdi", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = common.linkage });
+        @export(_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage });
+    @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fixtfdi(a: f128) callconv(.C) i64 {
diff --git a/lib/compiler_rt/fixtfsi.zig b/lib/compiler_rt/fixtfsi.zig
index 0f5e3924ae3d..389f2b117f47 100644
--- a/lib/compiler_rt/fixtfsi.zig
+++ b/lib/compiler_rt/fixtfsi.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixtfsi, .{ .name = "__fixkfsi", .linkage = common.linkage });
+        @export(__fixtfsi, .{ .name = "__fixkfsi", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = common.linkage });
+        @export(_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage });
+    @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fixtfsi(a: f128) callconv(.C) i32 {
diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig
index ba46eb85980a..03d861f92e3c 100644
--- a/lib/compiler_rt/fixtfti.zig
+++ b/lib/compiler_rt/fixtfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixtfti_windows_x86_64, .{ .name = "__fixtfti", .linkage = common.linkage });
+        @export(__fixtfti_windows_x86_64, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage });
+        @export(__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunsdfdi.zig b/lib/compiler_rt/fixunsdfdi.zig
index edc0806405ba..b544595c7f70 100644
--- a/lib/compiler_rt/fixunsdfdi.zig
+++ b/lib/compiler_rt/fixunsdfdi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = common.linkage });
+        @export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = common.linkage });
+        @export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunsdfsi.zig b/lib/compiler_rt/fixunsdfsi.zig
index cc413f3983d0..87affbce329c 100644
--- a/lib/compiler_rt/fixunsdfsi.zig
+++ b/lib/compiler_rt/fixunsdfsi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = common.linkage });
+        @export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = common.linkage });
+        @export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig
index 00a89ba2d6f0..242d84176b45 100644
--- a/lib/compiler_rt/fixunsdfti.zig
+++ b/lib/compiler_rt/fixunsdfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage });
+        @export(__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage });
+        @export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunshfdi.zig b/lib/compiler_rt/fixunshfdi.zig
index 5058bc5e688d..9c70df3d5eaa 100644
--- a/lib/compiler_rt/fixunshfdi.zig
+++ b/lib/compiler_rt/fixunshfdi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixunshfdi, .{ .name = "__fixunshfdi", .linkage = common.linkage });
+    @export(__fixunshfdi, .{ .name = "__fixunshfdi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixunshfdi(a: f16) callconv(.C) u64 {
diff --git a/lib/compiler_rt/fixunshfsi.zig b/lib/compiler_rt/fixunshfsi.zig
index 5755048814e2..e5070f7a1b29 100644
--- a/lib/compiler_rt/fixunshfsi.zig
+++ b/lib/compiler_rt/fixunshfsi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixunshfsi, .{ .name = "__fixunshfsi", .linkage = common.linkage });
+    @export(__fixunshfsi, .{ .name = "__fixunshfsi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixunshfsi(a: f16) callconv(.C) u32 {
diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig
index 4f5179bfb5bf..f7dcb3f7907e 100644
--- a/lib/compiler_rt/fixunshfti.zig
+++ b/lib/compiler_rt/fixunshfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixunshfti_windows_x86_64, .{ .name = "__fixunshfti", .linkage = common.linkage });
+        @export(__fixunshfti_windows_x86_64, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage });
+        @export(__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunssfdi.zig b/lib/compiler_rt/fixunssfdi.zig
index 544dfcd97ed0..dd883693a7e9 100644
--- a/lib/compiler_rt/fixunssfdi.zig
+++ b/lib/compiler_rt/fixunssfdi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = common.linkage });
+        @export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = common.linkage });
+        @export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunssfsi.zig b/lib/compiler_rt/fixunssfsi.zig
index 24b1e8669419..a071e674ae22 100644
--- a/lib/compiler_rt/fixunssfsi.zig
+++ b/lib/compiler_rt/fixunssfsi.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = common.linkage });
+        @export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = common.linkage });
+        @export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig
index 0d3fa5d3b965..ae2a27ab8e83 100644
--- a/lib/compiler_rt/fixunssfti.zig
+++ b/lib/compiler_rt/fixunssfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixunssfti_windows_x86_64, .{ .name = "__fixunssfti", .linkage = common.linkage });
+        @export(__fixunssfti_windows_x86_64, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage });
+        @export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunstfdi.zig b/lib/compiler_rt/fixunstfdi.zig
index fb9ff5b33038..710207b330dc 100644
--- a/lib/compiler_rt/fixunstfdi.zig
+++ b/lib/compiler_rt/fixunstfdi.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixunstfdi, .{ .name = "__fixunskfdi", .linkage = common.linkage });
+        @export(__fixunstfdi, .{ .name = "__fixunskfdi", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_qtoux, .{ .name = "_Qp_qtoux", .linkage = common.linkage });
+        @export(_Qp_qtoux, .{ .name = "_Qp_qtoux", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = common.linkage });
+    @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fixunstfdi(a: f128) callconv(.C) u64 {
diff --git a/lib/compiler_rt/fixunstfsi.zig b/lib/compiler_rt/fixunstfsi.zig
index 79cacbe34062..1b0b64c193a4 100644
--- a/lib/compiler_rt/fixunstfsi.zig
+++ b/lib/compiler_rt/fixunstfsi.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixunstfsi, .{ .name = "__fixunskfsi", .linkage = common.linkage });
+        @export(__fixunstfsi, .{ .name = "__fixunskfsi", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_qtoui, .{ .name = "_Qp_qtoui", .linkage = common.linkage });
+        @export(_Qp_qtoui, .{ .name = "_Qp_qtoui", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = common.linkage });
+    @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fixunstfsi(a: f128) callconv(.C) u32 {
diff --git a/lib/compiler_rt/fixunstfti.zig b/lib/compiler_rt/fixunstfti.zig
index 02cabd4d46bb..72b529e0c90a 100644
--- a/lib/compiler_rt/fixunstfti.zig
+++ b/lib/compiler_rt/fixunstfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixunstfti_windows_x86_64, .{ .name = "__fixunstfti", .linkage = common.linkage });
+        @export(__fixunstfti_windows_x86_64, .{ .name = "__fixunstfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = common.linkage });
+        @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixunsxfdi.zig b/lib/compiler_rt/fixunsxfdi.zig
index cb2760af4e77..de1cd138062f 100644
--- a/lib/compiler_rt/fixunsxfdi.zig
+++ b/lib/compiler_rt/fixunsxfdi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = common.linkage });
+    @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixunsxfdi(a: f80) callconv(.C) u64 {
diff --git a/lib/compiler_rt/fixunsxfsi.zig b/lib/compiler_rt/fixunsxfsi.zig
index bec36abbf4f8..93cdcb2bab8e 100644
--- a/lib/compiler_rt/fixunsxfsi.zig
+++ b/lib/compiler_rt/fixunsxfsi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = common.linkage });
+    @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixunsxfsi(a: f80) callconv(.C) u32 {
diff --git a/lib/compiler_rt/fixunsxfti.zig b/lib/compiler_rt/fixunsxfti.zig
index 1cf5891f92ce..a34bd288c098 100644
--- a/lib/compiler_rt/fixunsxfti.zig
+++ b/lib/compiler_rt/fixunsxfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixunsxfti_windows_x86_64, .{ .name = "__fixunsxfti", .linkage = common.linkage });
+        @export(__fixunsxfti_windows_x86_64, .{ .name = "__fixunsxfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = common.linkage });
+        @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/fixxfdi.zig b/lib/compiler_rt/fixxfdi.zig
index 0f249e0a9218..096e381629b5 100644
--- a/lib/compiler_rt/fixxfdi.zig
+++ b/lib/compiler_rt/fixxfdi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage });
+    @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixxfdi(a: f80) callconv(.C) i64 {
diff --git a/lib/compiler_rt/fixxfsi.zig b/lib/compiler_rt/fixxfsi.zig
index ac2158b7b8cc..b6714d20663b 100644
--- a/lib/compiler_rt/fixxfsi.zig
+++ b/lib/compiler_rt/fixxfsi.zig
@@ -4,7 +4,7 @@ const floatToInt = @import("./float_to_int.zig").floatToInt;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = common.linkage });
+    @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __fixxfsi(a: f80) callconv(.C) i32 {
diff --git a/lib/compiler_rt/fixxfti.zig b/lib/compiler_rt/fixxfti.zig
index 9a40ec3d6a13..2e9dbdc2fbc6 100644
--- a/lib/compiler_rt/fixxfti.zig
+++ b/lib/compiler_rt/fixxfti.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__fixxfti_windows_x86_64, .{ .name = "__fixxfti", .linkage = common.linkage });
+        @export(__fixxfti_windows_x86_64, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__fixxfti, .{ .name = "__fixxfti", .linkage = common.linkage });
+        @export(__fixxfti, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatdidf.zig b/lib/compiler_rt/floatdidf.zig
index 9117e2189dc7..9b9df4ae7016 100644
--- a/lib/compiler_rt/floatdidf.zig
+++ b/lib/compiler_rt/floatdidf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = common.linkage });
+        @export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatdidf, .{ .name = "__floatdidf", .linkage = common.linkage });
+        @export(__floatdidf, .{ .name = "__floatdidf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatdihf.zig b/lib/compiler_rt/floatdihf.zig
index f2f7236d6f42..1db7a0eac670 100644
--- a/lib/compiler_rt/floatdihf.zig
+++ b/lib/compiler_rt/floatdihf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatdihf, .{ .name = "__floatdihf", .linkage = common.linkage });
+    @export(__floatdihf, .{ .name = "__floatdihf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __floatdihf(a: i64) callconv(.C) f16 {
diff --git a/lib/compiler_rt/floatdisf.zig b/lib/compiler_rt/floatdisf.zig
index 3de94c5103d2..3bdcc60f20fd 100644
--- a/lib/compiler_rt/floatdisf.zig
+++ b/lib/compiler_rt/floatdisf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage });
+        @export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage });
+        @export(__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatditf.zig b/lib/compiler_rt/floatditf.zig
index 1f651b817b53..173dd79f753e 100644
--- a/lib/compiler_rt/floatditf.zig
+++ b/lib/compiler_rt/floatditf.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatditf, .{ .name = "__floatdikf", .linkage = common.linkage });
+        @export(__floatditf, .{ .name = "__floatdikf", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = common.linkage });
+        @export(_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__floatditf, .{ .name = "__floatditf", .linkage = common.linkage });
+    @export(__floatditf, .{ .name = "__floatditf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __floatditf(a: i64) callconv(.C) f128 {
diff --git a/lib/compiler_rt/floatdixf.zig b/lib/compiler_rt/floatdixf.zig
index 7d80fdbeb898..c4fc9ca28f9f 100644
--- a/lib/compiler_rt/floatdixf.zig
+++ b/lib/compiler_rt/floatdixf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatdixf, .{ .name = "__floatdixf", .linkage = common.linkage });
+    @export(__floatdixf, .{ .name = "__floatdixf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __floatdixf(a: i64) callconv(.C) f80 {
diff --git a/lib/compiler_rt/floatsidf.zig b/lib/compiler_rt/floatsidf.zig
index e31c2616fd1e..7ec7d90fbada 100644
--- a/lib/compiler_rt/floatsidf.zig
+++ b/lib/compiler_rt/floatsidf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = common.linkage });
+        @export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatsidf, .{ .name = "__floatsidf", .linkage = common.linkage });
+        @export(__floatsidf, .{ .name = "__floatsidf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatsihf.zig b/lib/compiler_rt/floatsihf.zig
index 84b54298b5ec..0a08c19847e1 100644
--- a/lib/compiler_rt/floatsihf.zig
+++ b/lib/compiler_rt/floatsihf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatsihf, .{ .name = "__floatsihf", .linkage = common.linkage });
+    @export(__floatsihf, .{ .name = "__floatsihf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __floatsihf(a: i32) callconv(.C) f16 {
diff --git a/lib/compiler_rt/floatsisf.zig b/lib/compiler_rt/floatsisf.zig
index 87f83315c17b..daddfb06e154 100644
--- a/lib/compiler_rt/floatsisf.zig
+++ b/lib/compiler_rt/floatsisf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = common.linkage });
+        @export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatsisf, .{ .name = "__floatsisf", .linkage = common.linkage });
+        @export(__floatsisf, .{ .name = "__floatsisf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatsitf.zig b/lib/compiler_rt/floatsitf.zig
index 20473fa1d03a..9739b912803c 100644
--- a/lib/compiler_rt/floatsitf.zig
+++ b/lib/compiler_rt/floatsitf.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatsitf, .{ .name = "__floatsikf", .linkage = common.linkage });
+        @export(__floatsitf, .{ .name = "__floatsikf", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_itoq, .{ .name = "_Qp_itoq", .linkage = common.linkage });
+        @export(_Qp_itoq, .{ .name = "_Qp_itoq", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__floatsitf, .{ .name = "__floatsitf", .linkage = common.linkage });
+    @export(__floatsitf, .{ .name = "__floatsitf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __floatsitf(a: i32) callconv(.C) f128 {
diff --git a/lib/compiler_rt/floatsixf.zig b/lib/compiler_rt/floatsixf.zig
index 76d266e17a0a..a9d3709911eb 100644
--- a/lib/compiler_rt/floatsixf.zig
+++ b/lib/compiler_rt/floatsixf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatsixf, .{ .name = "__floatsixf", .linkage = common.linkage });
+    @export(__floatsixf, .{ .name = "__floatsixf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __floatsixf(a: i32) callconv(.C) f80 {
diff --git a/lib/compiler_rt/floattidf.zig b/lib/compiler_rt/floattidf.zig
index 31456948e9d8..d70fedbfc301 100644
--- a/lib/compiler_rt/floattidf.zig
+++ b/lib/compiler_rt/floattidf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floattidf_windows_x86_64, .{ .name = "__floattidf", .linkage = common.linkage });
+        @export(__floattidf_windows_x86_64, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floattidf, .{ .name = "__floattidf", .linkage = common.linkage });
+        @export(__floattidf, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floattihf.zig b/lib/compiler_rt/floattihf.zig
index 3e33a0bd8a45..f90a57d1e0ba 100644
--- a/lib/compiler_rt/floattihf.zig
+++ b/lib/compiler_rt/floattihf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floattihf_windows_x86_64, .{ .name = "__floattihf", .linkage = common.linkage });
+        @export(__floattihf_windows_x86_64, .{ .name = "__floattihf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floattihf, .{ .name = "__floattihf", .linkage = common.linkage });
+        @export(__floattihf, .{ .name = "__floattihf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floattisf.zig b/lib/compiler_rt/floattisf.zig
index 23ff0d16b402..737e1ec40950 100644
--- a/lib/compiler_rt/floattisf.zig
+++ b/lib/compiler_rt/floattisf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floattisf_windows_x86_64, .{ .name = "__floattisf", .linkage = common.linkage });
+        @export(__floattisf_windows_x86_64, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floattisf, .{ .name = "__floattisf", .linkage = common.linkage });
+        @export(__floattisf, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floattitf.zig b/lib/compiler_rt/floattitf.zig
index c44473cc3d50..62c215c986ff 100644
--- a/lib/compiler_rt/floattitf.zig
+++ b/lib/compiler_rt/floattitf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floattitf_windows_x86_64, .{ .name = "__floattitf", .linkage = common.linkage });
+        @export(__floattitf_windows_x86_64, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floattitf, .{ .name = "__floattitf", .linkage = common.linkage });
+        @export(__floattitf, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floattixf.zig b/lib/compiler_rt/floattixf.zig
index 814880b9ab66..1af4f83965fb 100644
--- a/lib/compiler_rt/floattixf.zig
+++ b/lib/compiler_rt/floattixf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floattixf_windows_x86_64, .{ .name = "__floattixf", .linkage = common.linkage });
+        @export(__floattixf_windows_x86_64, .{ .name = "__floattixf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floattixf, .{ .name = "__floattixf", .linkage = common.linkage });
+        @export(__floattixf, .{ .name = "__floattixf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatundidf.zig b/lib/compiler_rt/floatundidf.zig
index d49575639ed4..db4cc6505e1f 100644
--- a/lib/compiler_rt/floatundidf.zig
+++ b/lib/compiler_rt/floatundidf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage });
+        @export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage });
+        @export(__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatundihf.zig b/lib/compiler_rt/floatundihf.zig
index 6eff8aaec3a3..e6c6a79d5e72 100644
--- a/lib/compiler_rt/floatundihf.zig
+++ b/lib/compiler_rt/floatundihf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatundihf, .{ .name = "__floatundihf", .linkage = common.linkage });
+    @export(__floatundihf, .{ .name = "__floatundihf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __floatundihf(a: u64) callconv(.C) f16 {
diff --git a/lib/compiler_rt/floatundisf.zig b/lib/compiler_rt/floatundisf.zig
index 963670d85bd4..eb17c0f657de 100644
--- a/lib/compiler_rt/floatundisf.zig
+++ b/lib/compiler_rt/floatundisf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = common.linkage });
+        @export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatundisf, .{ .name = "__floatundisf", .linkage = common.linkage });
+        @export(__floatundisf, .{ .name = "__floatundisf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatunditf.zig b/lib/compiler_rt/floatunditf.zig
index 9236f4705f1f..0bfa36d6e185 100644
--- a/lib/compiler_rt/floatunditf.zig
+++ b/lib/compiler_rt/floatunditf.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatunditf, .{ .name = "__floatundikf", .linkage = common.linkage });
+        @export(__floatunditf, .{ .name = "__floatundikf", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_uxtoq, .{ .name = "_Qp_uxtoq", .linkage = common.linkage });
+        @export(_Qp_uxtoq, .{ .name = "_Qp_uxtoq", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__floatunditf, .{ .name = "__floatunditf", .linkage = common.linkage });
+    @export(__floatunditf, .{ .name = "__floatunditf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __floatunditf(a: u64) callconv(.C) f128 {
diff --git a/lib/compiler_rt/floatundixf.zig b/lib/compiler_rt/floatundixf.zig
index 331b74df4f83..22f885167f32 100644
--- a/lib/compiler_rt/floatundixf.zig
+++ b/lib/compiler_rt/floatundixf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatundixf, .{ .name = "__floatundixf", .linkage = common.linkage });
+    @export(__floatundixf, .{ .name = "__floatundixf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __floatundixf(a: u64) callconv(.C) f80 {
diff --git a/lib/compiler_rt/floatunsidf.zig b/lib/compiler_rt/floatunsidf.zig
index 1f5a47287a0d..ef5bce2afaef 100644
--- a/lib/compiler_rt/floatunsidf.zig
+++ b/lib/compiler_rt/floatunsidf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = common.linkage });
+        @export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = common.linkage });
+        @export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatunsihf.zig b/lib/compiler_rt/floatunsihf.zig
index b2f679c18c3d..0b43d61f4cc2 100644
--- a/lib/compiler_rt/floatunsihf.zig
+++ b/lib/compiler_rt/floatunsihf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage });
+    @export(__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __floatunsihf(a: u32) callconv(.C) f16 {
diff --git a/lib/compiler_rt/floatunsisf.zig b/lib/compiler_rt/floatunsisf.zig
index 46f336a4d8b9..f85d1bb01371 100644
--- a/lib/compiler_rt/floatunsisf.zig
+++ b/lib/compiler_rt/floatunsisf.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = common.linkage });
+        @export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = common.linkage });
+        @export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatunsitf.zig b/lib/compiler_rt/floatunsitf.zig
index af454e1e028d..ef9593cdf600 100644
--- a/lib/compiler_rt/floatunsitf.zig
+++ b/lib/compiler_rt/floatunsitf.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatunsitf, .{ .name = "__floatunsikf", .linkage = common.linkage });
+        @export(__floatunsitf, .{ .name = "__floatunsikf", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = common.linkage });
+        @export(_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage });
+    @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __floatunsitf(a: u32) callconv(.C) f128 {
diff --git a/lib/compiler_rt/floatunsixf.zig b/lib/compiler_rt/floatunsixf.zig
index 40492564fcd6..cd402e227ded 100644
--- a/lib/compiler_rt/floatunsixf.zig
+++ b/lib/compiler_rt/floatunsixf.zig
@@ -4,7 +4,7 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = common.linkage });
+    @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __floatunsixf(a: u32) callconv(.C) f80 {
diff --git a/lib/compiler_rt/floatuntidf.zig b/lib/compiler_rt/floatuntidf.zig
index a00175d9a9f2..d3a685a1ce16 100644
--- a/lib/compiler_rt/floatuntidf.zig
+++ b/lib/compiler_rt/floatuntidf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floatuntidf_windows_x86_64, .{ .name = "__floatuntidf", .linkage = common.linkage });
+        @export(__floatuntidf_windows_x86_64, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage });
+        @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatuntihf.zig b/lib/compiler_rt/floatuntihf.zig
index 3cf7a32d270c..9102960e8d70 100644
--- a/lib/compiler_rt/floatuntihf.zig
+++ b/lib/compiler_rt/floatuntihf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floatuntihf_windows_x86_64, .{ .name = "__floatuntihf", .linkage = common.linkage });
+        @export(__floatuntihf_windows_x86_64, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatuntihf, .{ .name = "__floatuntihf", .linkage = common.linkage });
+        @export(__floatuntihf, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatuntisf.zig b/lib/compiler_rt/floatuntisf.zig
index 997d57293e7d..7ee013339d70 100644
--- a/lib/compiler_rt/floatuntisf.zig
+++ b/lib/compiler_rt/floatuntisf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floatuntisf_windows_x86_64, .{ .name = "__floatuntisf", .linkage = common.linkage });
+        @export(__floatuntisf_windows_x86_64, .{ .name = "__floatuntisf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = common.linkage });
+        @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig
index ee386bc96ba5..413d9253d08a 100644
--- a/lib/compiler_rt/floatuntitf.zig
+++ b/lib/compiler_rt/floatuntitf.zig
@@ -6,12 +6,12 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floatuntitf_windows_x86_64, .{ .name = "__floatuntitf", .linkage = common.linkage });
+        @export(__floatuntitf_windows_x86_64, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
         if (common.want_ppc_abi) {
-            @export(__floatuntitf, .{ .name = "__floatuntikf", .linkage = common.linkage });
+            @export(__floatuntitf, .{ .name = "__floatuntikf", .linkage = common.linkage, .visibility = common.visibility });
         }
-        @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage });
+        @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floatuntixf.zig b/lib/compiler_rt/floatuntixf.zig
index 724af9507514..877203bd223f 100644
--- a/lib/compiler_rt/floatuntixf.zig
+++ b/lib/compiler_rt/floatuntixf.zig
@@ -6,9 +6,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__floatuntixf_windows_x86_64, .{ .name = "__floatuntixf", .linkage = common.linkage });
+        @export(__floatuntixf_windows_x86_64, .{ .name = "__floatuntixf", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = common.linkage });
+        @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/floor.zig b/lib/compiler_rt/floor.zig
index afdc825f9f83..ea274c0d8295 100644
--- a/lib/compiler_rt/floor.zig
+++ b/lib/compiler_rt/floor.zig
@@ -14,15 +14,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__floorh, .{ .name = "__floorh", .linkage = common.linkage });
-    @export(floorf, .{ .name = "floorf", .linkage = common.linkage });
-    @export(floor, .{ .name = "floor", .linkage = common.linkage });
-    @export(__floorx, .{ .name = "__floorx", .linkage = common.linkage });
+    @export(__floorh, .{ .name = "__floorh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(floorf, .{ .name = "floorf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(floor, .{ .name = "floor", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__floorx, .{ .name = "__floorx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(floorq, .{ .name = "floorf128", .linkage = common.linkage });
+        @export(floorq, .{ .name = "floorf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(floorq, .{ .name = "floorq", .linkage = common.linkage });
-    @export(floorl, .{ .name = "floorl", .linkage = common.linkage });
+    @export(floorq, .{ .name = "floorq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(floorl, .{ .name = "floorl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __floorh(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig
index 4bde30f50f16..fe2da1c99c68 100644
--- a/lib/compiler_rt/fma.zig
+++ b/lib/compiler_rt/fma.zig
@@ -15,15 +15,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__fmah, .{ .name = "__fmah", .linkage = common.linkage });
-    @export(fmaf, .{ .name = "fmaf", .linkage = common.linkage });
-    @export(fma, .{ .name = "fma", .linkage = common.linkage });
-    @export(__fmax, .{ .name = "__fmax", .linkage = common.linkage });
+    @export(__fmah, .{ .name = "__fmah", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmaf, .{ .name = "fmaf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fma, .{ .name = "fma", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__fmax, .{ .name = "__fmax", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(fmaq, .{ .name = "fmaf128", .linkage = common.linkage });
+        @export(fmaq, .{ .name = "fmaf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(fmaq, .{ .name = "fmaq", .linkage = common.linkage });
-    @export(fmal, .{ .name = "fmal", .linkage = common.linkage });
+    @export(fmaq, .{ .name = "fmaq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmal, .{ .name = "fmal", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fmah(x: f16, y: f16, z: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/fmax.zig b/lib/compiler_rt/fmax.zig
index df7c4a7f2e9e..9645b665f309 100644
--- a/lib/compiler_rt/fmax.zig
+++ b/lib/compiler_rt/fmax.zig
@@ -7,15 +7,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__fmaxh, .{ .name = "__fmaxh", .linkage = common.linkage });
-    @export(fmaxf, .{ .name = "fmaxf", .linkage = common.linkage });
-    @export(fmax, .{ .name = "fmax", .linkage = common.linkage });
-    @export(__fmaxx, .{ .name = "__fmaxx", .linkage = common.linkage });
+    @export(__fmaxh, .{ .name = "__fmaxh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmaxf, .{ .name = "fmaxf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmax, .{ .name = "fmax", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__fmaxx, .{ .name = "__fmaxx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(fmaxq, .{ .name = "fmaxf128", .linkage = common.linkage });
+        @export(fmaxq, .{ .name = "fmaxf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(fmaxq, .{ .name = "fmaxq", .linkage = common.linkage });
-    @export(fmaxl, .{ .name = "fmaxl", .linkage = common.linkage });
+    @export(fmaxq, .{ .name = "fmaxq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmaxl, .{ .name = "fmaxl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fmaxh(x: f16, y: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/fmin.zig b/lib/compiler_rt/fmin.zig
index 7565f3a572db..6cb7f8544e48 100644
--- a/lib/compiler_rt/fmin.zig
+++ b/lib/compiler_rt/fmin.zig
@@ -7,15 +7,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__fminh, .{ .name = "__fminh", .linkage = common.linkage });
-    @export(fminf, .{ .name = "fminf", .linkage = common.linkage });
-    @export(fmin, .{ .name = "fmin", .linkage = common.linkage });
-    @export(__fminx, .{ .name = "__fminx", .linkage = common.linkage });
+    @export(__fminh, .{ .name = "__fminh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fminf, .{ .name = "fminf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmin, .{ .name = "fmin", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__fminx, .{ .name = "__fminx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(fminq, .{ .name = "fminf128", .linkage = common.linkage });
+        @export(fminq, .{ .name = "fminf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(fminq, .{ .name = "fminq", .linkage = common.linkage });
-    @export(fminl, .{ .name = "fminl", .linkage = common.linkage });
+    @export(fminq, .{ .name = "fminq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fminl, .{ .name = "fminl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fminh(x: f16, y: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig
index e276b9988476..b80dffdb820b 100644
--- a/lib/compiler_rt/fmod.zig
+++ b/lib/compiler_rt/fmod.zig
@@ -9,15 +9,15 @@ const normalize = common.normalize;
 pub const panic = common.panic;
 
 comptime {
-    @export(__fmodh, .{ .name = "__fmodh", .linkage = common.linkage });
-    @export(fmodf, .{ .name = "fmodf", .linkage = common.linkage });
-    @export(fmod, .{ .name = "fmod", .linkage = common.linkage });
-    @export(__fmodx, .{ .name = "__fmodx", .linkage = common.linkage });
+    @export(__fmodh, .{ .name = "__fmodh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmodf, .{ .name = "fmodf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmod, .{ .name = "fmod", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__fmodx, .{ .name = "__fmodx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(fmodq, .{ .name = "fmodf128", .linkage = common.linkage });
+        @export(fmodq, .{ .name = "fmodf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(fmodq, .{ .name = "fmodq", .linkage = common.linkage });
-    @export(fmodl, .{ .name = "fmodl", .linkage = common.linkage });
+    @export(fmodq, .{ .name = "fmodq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(fmodl, .{ .name = "fmodl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __fmodh(x: f16, y: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/gedf2.zig b/lib/compiler_rt/gedf2.zig
index 684ba665b52c..c887a9b6e4ff 100644
--- a/lib/compiler_rt/gedf2.zig
+++ b/lib/compiler_rt/gedf2.zig
@@ -7,11 +7,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = common.linkage });
-        @export(__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage });
+        @export(__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__gedf2, .{ .name = "__gedf2", .linkage = common.linkage });
-        @export(__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage });
+        @export(__gedf2, .{ .name = "__gedf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/gehf2.zig b/lib/compiler_rt/gehf2.zig
index 651cbf943f9a..e3df4d30874c 100644
--- a/lib/compiler_rt/gehf2.zig
+++ b/lib/compiler_rt/gehf2.zig
@@ -6,8 +6,8 @@ const comparef = @import("./comparef.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__gehf2, .{ .name = "__gehf2", .linkage = common.linkage });
-    @export(__gthf2, .{ .name = "__gthf2", .linkage = common.linkage });
+    @export(__gehf2, .{ .name = "__gehf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__gthf2, .{ .name = "__gthf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 /// "These functions return a value greater than or equal to zero if neither
diff --git a/lib/compiler_rt/gesf2.zig b/lib/compiler_rt/gesf2.zig
index 3d455e52bfd3..44439976bbea 100644
--- a/lib/compiler_rt/gesf2.zig
+++ b/lib/compiler_rt/gesf2.zig
@@ -7,11 +7,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = common.linkage });
-        @export(__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = common.linkage });
+        @export(__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__gesf2, .{ .name = "__gesf2", .linkage = common.linkage });
-        @export(__gtsf2, .{ .name = "__gtsf2", .linkage = common.linkage });
+        @export(__gesf2, .{ .name = "__gesf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__gtsf2, .{ .name = "__gtsf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/getf2.zig b/lib/compiler_rt/getf2.zig
index 831736250fd1..1a5c06af3d73 100644
--- a/lib/compiler_rt/getf2.zig
+++ b/lib/compiler_rt/getf2.zig
@@ -7,14 +7,14 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__getf2, .{ .name = "__gekf2", .linkage = common.linkage });
-        @export(__gttf2, .{ .name = "__gtkf2", .linkage = common.linkage });
+        @export(__getf2, .{ .name = "__gekf2", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__gttf2, .{ .name = "__gtkf2", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
         // These exports are handled in cmptf2.zig because gt and ge on sparc
         // are based on calling _Qp_cmp.
     }
-    @export(__getf2, .{ .name = "__getf2", .linkage = common.linkage });
-    @export(__gttf2, .{ .name = "__gttf2", .linkage = common.linkage });
+    @export(__getf2, .{ .name = "__getf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__gttf2, .{ .name = "__gttf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 /// "These functions return a value greater than or equal to zero if neither
diff --git a/lib/compiler_rt/gexf2.zig b/lib/compiler_rt/gexf2.zig
index 6bb88fbb8f4e..bf0b0edccb07 100644
--- a/lib/compiler_rt/gexf2.zig
+++ b/lib/compiler_rt/gexf2.zig
@@ -4,8 +4,8 @@ const comparef = @import("./comparef.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__gexf2, .{ .name = "__gexf2", .linkage = common.linkage });
-    @export(__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage });
+    @export(__gexf2, .{ .name = "__gexf2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __gexf2(a: f80, b: f80) callconv(.C) i32 {
diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig
index 43bc160cda9f..b844af185983 100644
--- a/lib/compiler_rt/int.zig
+++ b/lib/compiler_rt/int.zig
@@ -13,24 +13,24 @@ const udivmod = @import("udivmod.zig").udivmod;
 pub const panic = common.panic;
 
 comptime {
-    @export(__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = common.linkage });
-    @export(__mulsi3, .{ .name = "__mulsi3", .linkage = common.linkage });
-    @export(__divmoddi4, .{ .name = "__divmoddi4", .linkage = common.linkage });
+    @export(__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__mulsi3, .{ .name = "__mulsi3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__divmoddi4, .{ .name = "__divmoddi4", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_aeabi) {
-        @export(__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = common.linkage });
-        @export(__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = common.linkage });
+        @export(__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__divsi3, .{ .name = "__divsi3", .linkage = common.linkage });
-        @export(__udivsi3, .{ .name = "__udivsi3", .linkage = common.linkage });
+        @export(__divsi3, .{ .name = "__divsi3", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__udivsi3, .{ .name = "__udivsi3", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__divdi3, .{ .name = "__divdi3", .linkage = common.linkage });
-    @export(__udivdi3, .{ .name = "__udivdi3", .linkage = common.linkage });
-    @export(__modsi3, .{ .name = "__modsi3", .linkage = common.linkage });
-    @export(__moddi3, .{ .name = "__moddi3", .linkage = common.linkage });
-    @export(__umodsi3, .{ .name = "__umodsi3", .linkage = common.linkage });
-    @export(__umoddi3, .{ .name = "__umoddi3", .linkage = common.linkage });
-    @export(__divmodsi4, .{ .name = "__divmodsi4", .linkage = common.linkage });
-    @export(__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = common.linkage });
+    @export(__divdi3, .{ .name = "__divdi3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__udivdi3, .{ .name = "__udivdi3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__modsi3, .{ .name = "__modsi3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__moddi3, .{ .name = "__moddi3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__umodsi3, .{ .name = "__umodsi3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__umoddi3, .{ .name = "__umoddi3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__divmodsi4, .{ .name = "__divmodsi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __divmoddi4(a: i64, b: i64, rem: *i64) callconv(.C) i64 {
diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig
index 5e7085a41bd8..71d90f7c3a7c 100644
--- a/lib/compiler_rt/log.zig
+++ b/lib/compiler_rt/log.zig
@@ -14,15 +14,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__logh, .{ .name = "__logh", .linkage = common.linkage });
-    @export(logf, .{ .name = "logf", .linkage = common.linkage });
-    @export(log, .{ .name = "log", .linkage = common.linkage });
-    @export(__logx, .{ .name = "__logx", .linkage = common.linkage });
+    @export(__logh, .{ .name = "__logh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(logf, .{ .name = "logf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(log, .{ .name = "log", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__logx, .{ .name = "__logx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(logq, .{ .name = "logf128", .linkage = common.linkage });
+        @export(logq, .{ .name = "logf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(logq, .{ .name = "logq", .linkage = common.linkage });
-    @export(logl, .{ .name = "logl", .linkage = common.linkage });
+    @export(logq, .{ .name = "logq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(logl, .{ .name = "logl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __logh(a: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig
index 54638cc6458f..5c345ff12f70 100644
--- a/lib/compiler_rt/log10.zig
+++ b/lib/compiler_rt/log10.zig
@@ -15,15 +15,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__log10h, .{ .name = "__log10h", .linkage = common.linkage });
-    @export(log10f, .{ .name = "log10f", .linkage = common.linkage });
-    @export(log10, .{ .name = "log10", .linkage = common.linkage });
-    @export(__log10x, .{ .name = "__log10x", .linkage = common.linkage });
+    @export(__log10h, .{ .name = "__log10h", .linkage = common.linkage, .visibility = common.visibility });
+    @export(log10f, .{ .name = "log10f", .linkage = common.linkage, .visibility = common.visibility });
+    @export(log10, .{ .name = "log10", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__log10x, .{ .name = "__log10x", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(log10q, .{ .name = "log10f128", .linkage = common.linkage });
+        @export(log10q, .{ .name = "log10f128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(log10q, .{ .name = "log10q", .linkage = common.linkage });
-    @export(log10l, .{ .name = "log10l", .linkage = common.linkage });
+    @export(log10q, .{ .name = "log10q", .linkage = common.linkage, .visibility = common.visibility });
+    @export(log10l, .{ .name = "log10l", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __log10h(a: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/log2.zig b/lib/compiler_rt/log2.zig
index 8298c3dbe325..612c97859866 100644
--- a/lib/compiler_rt/log2.zig
+++ b/lib/compiler_rt/log2.zig
@@ -15,15 +15,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__log2h, .{ .name = "__log2h", .linkage = common.linkage });
-    @export(log2f, .{ .name = "log2f", .linkage = common.linkage });
-    @export(log2, .{ .name = "log2", .linkage = common.linkage });
-    @export(__log2x, .{ .name = "__log2x", .linkage = common.linkage });
+    @export(__log2h, .{ .name = "__log2h", .linkage = common.linkage, .visibility = common.visibility });
+    @export(log2f, .{ .name = "log2f", .linkage = common.linkage, .visibility = common.visibility });
+    @export(log2, .{ .name = "log2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__log2x, .{ .name = "__log2x", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(log2q, .{ .name = "log2f128", .linkage = common.linkage });
+        @export(log2q, .{ .name = "log2f128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(log2q, .{ .name = "log2q", .linkage = common.linkage });
-    @export(log2l, .{ .name = "log2l", .linkage = common.linkage });
+    @export(log2q, .{ .name = "log2q", .linkage = common.linkage, .visibility = common.visibility });
+    @export(log2l, .{ .name = "log2l", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __log2h(a: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/memcmp.zig b/lib/compiler_rt/memcmp.zig
index 6f7e48135b6b..b337e6f29e43 100644
--- a/lib/compiler_rt/memcmp.zig
+++ b/lib/compiler_rt/memcmp.zig
@@ -2,7 +2,7 @@ const std = @import("std");
 const common = @import("./common.zig");
 
 comptime {
-    @export(memcmp, .{ .name = "memcmp", .linkage = common.linkage });
+    @export(memcmp, .{ .name = "memcmp", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn memcmp(vl: [*]const u8, vr: [*]const u8, n: usize) callconv(.C) c_int {
diff --git a/lib/compiler_rt/memcpy.zig b/lib/compiler_rt/memcpy.zig
index 8f58fe909ca0..410117b6c37e 100644
--- a/lib/compiler_rt/memcpy.zig
+++ b/lib/compiler_rt/memcpy.zig
@@ -4,7 +4,7 @@ const builtin = @import("builtin");
 
 comptime {
     if (builtin.object_format != .c) {
-        @export(memcpy, .{ .name = "memcpy", .linkage = common.linkage });
+        @export(memcpy, .{ .name = "memcpy", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/memmove.zig b/lib/compiler_rt/memmove.zig
index 73d86795291f..61ccb1205d2d 100644
--- a/lib/compiler_rt/memmove.zig
+++ b/lib/compiler_rt/memmove.zig
@@ -2,7 +2,7 @@ const std = @import("std");
 const common = @import("./common.zig");
 
 comptime {
-    @export(memmove, .{ .name = "memmove", .linkage = common.linkage });
+    @export(memmove, .{ .name = "memmove", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.C) ?[*]u8 {
diff --git a/lib/compiler_rt/memset.zig b/lib/compiler_rt/memset.zig
index e88e74079aa3..25c549360710 100644
--- a/lib/compiler_rt/memset.zig
+++ b/lib/compiler_rt/memset.zig
@@ -4,8 +4,8 @@ const builtin = @import("builtin");
 
 comptime {
     if (builtin.object_format != .c) {
-        @export(memset, .{ .name = "memset", .linkage = common.linkage });
-        @export(__memset, .{ .name = "__memset", .linkage = common.linkage });
+        @export(memset, .{ .name = "memset", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__memset, .{ .name = "__memset", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/modti3.zig b/lib/compiler_rt/modti3.zig
index 9992f716eefd..ef02a697bc81 100644
--- a/lib/compiler_rt/modti3.zig
+++ b/lib/compiler_rt/modti3.zig
@@ -11,9 +11,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__modti3_windows_x86_64, .{ .name = "__modti3", .linkage = common.linkage });
+        @export(__modti3_windows_x86_64, .{ .name = "__modti3", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__modti3, .{ .name = "__modti3", .linkage = common.linkage });
+        @export(__modti3, .{ .name = "__modti3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/muldc3.zig b/lib/compiler_rt/muldc3.zig
index cef8f660b204..3a497fdedcc5 100644
--- a/lib/compiler_rt/muldc3.zig
+++ b/lib/compiler_rt/muldc3.zig
@@ -5,7 +5,7 @@ pub const panic = common.panic;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__muldc3, .{ .name = "__muldc3", .linkage = common.linkage });
+        @export(__muldc3, .{ .name = "__muldc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/muldf3.zig b/lib/compiler_rt/muldf3.zig
index ef7ab9fbf78d..81c698938178 100644
--- a/lib/compiler_rt/muldf3.zig
+++ b/lib/compiler_rt/muldf3.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = common.linkage });
+        @export(__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__muldf3, .{ .name = "__muldf3", .linkage = common.linkage });
+        @export(__muldf3, .{ .name = "__muldf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/muldi3.zig b/lib/compiler_rt/muldi3.zig
index a51c6c7b76f0..c79713fed0fa 100644
--- a/lib/compiler_rt/muldi3.zig
+++ b/lib/compiler_rt/muldi3.zig
@@ -10,9 +10,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_lmul, .{ .name = "__aeabi_lmul", .linkage = common.linkage });
+        @export(__aeabi_lmul, .{ .name = "__aeabi_lmul", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__muldi3, .{ .name = "__muldi3", .linkage = common.linkage });
+        @export(__muldi3, .{ .name = "__muldi3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/mulhc3.zig b/lib/compiler_rt/mulhc3.zig
index 70c68e2a72d0..cf44f1cc14ba 100644
--- a/lib/compiler_rt/mulhc3.zig
+++ b/lib/compiler_rt/mulhc3.zig
@@ -5,7 +5,7 @@ pub const panic = common.panic;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__mulhc3, .{ .name = "__mulhc3", .linkage = common.linkage });
+        @export(__mulhc3, .{ .name = "__mulhc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/mulhf3.zig b/lib/compiler_rt/mulhf3.zig
index 45251548bea8..c38c659092a7 100644
--- a/lib/compiler_rt/mulhf3.zig
+++ b/lib/compiler_rt/mulhf3.zig
@@ -4,7 +4,7 @@ const mulf3 = @import("./mulf3.zig").mulf3;
 pub const panic = common.panic;
 
 comptime {
-    @export(__mulhf3, .{ .name = "__mulhf3", .linkage = common.linkage });
+    @export(__mulhf3, .{ .name = "__mulhf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __mulhf3(a: f16, b: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/mulo.zig b/lib/compiler_rt/mulo.zig
index cd2d127c3447..13e58a78005c 100644
--- a/lib/compiler_rt/mulo.zig
+++ b/lib/compiler_rt/mulo.zig
@@ -6,9 +6,9 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__mulosi4, .{ .name = "__mulosi4", .linkage = common.linkage });
-    @export(__mulodi4, .{ .name = "__mulodi4", .linkage = common.linkage });
-    @export(__muloti4, .{ .name = "__muloti4", .linkage = common.linkage });
+    @export(__mulosi4, .{ .name = "__mulosi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__mulodi4, .{ .name = "__mulodi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__muloti4, .{ .name = "__muloti4", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 // mulo - multiplication overflow
diff --git a/lib/compiler_rt/mulsc3.zig b/lib/compiler_rt/mulsc3.zig
index 5fe289453b38..add389a59865 100644
--- a/lib/compiler_rt/mulsc3.zig
+++ b/lib/compiler_rt/mulsc3.zig
@@ -5,7 +5,7 @@ pub const panic = common.panic;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage });
+        @export(__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/mulsf3.zig b/lib/compiler_rt/mulsf3.zig
index 3294f5b1c780..27d0e09f3403 100644
--- a/lib/compiler_rt/mulsf3.zig
+++ b/lib/compiler_rt/mulsf3.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fmul, .{ .name = "__aeabi_fmul", .linkage = common.linkage });
+        @export(__aeabi_fmul, .{ .name = "__aeabi_fmul", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__mulsf3, .{ .name = "__mulsf3", .linkage = common.linkage });
+        @export(__mulsf3, .{ .name = "__mulsf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/multc3.zig b/lib/compiler_rt/multc3.zig
index 94f2205d7658..89054e4af816 100644
--- a/lib/compiler_rt/multc3.zig
+++ b/lib/compiler_rt/multc3.zig
@@ -5,7 +5,7 @@ pub const panic = common.panic;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__multc3, .{ .name = "__multc3", .linkage = common.linkage });
+        @export(__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/multf3.zig b/lib/compiler_rt/multf3.zig
index 878cd5c4ac61..453a869a83b7 100644
--- a/lib/compiler_rt/multf3.zig
+++ b/lib/compiler_rt/multf3.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__multf3, .{ .name = "__mulkf3", .linkage = common.linkage });
+        @export(__multf3, .{ .name = "__mulkf3", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_mul, .{ .name = "_Qp_mul", .linkage = common.linkage });
+        @export(_Qp_mul, .{ .name = "_Qp_mul", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__multf3, .{ .name = "__multf3", .linkage = common.linkage });
+    @export(__multf3, .{ .name = "__multf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __multf3(a: f128, b: f128) callconv(.C) f128 {
diff --git a/lib/compiler_rt/multi3.zig b/lib/compiler_rt/multi3.zig
index 9502dc5677ce..1918e8b976d9 100644
--- a/lib/compiler_rt/multi3.zig
+++ b/lib/compiler_rt/multi3.zig
@@ -11,9 +11,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__multi3_windows_x86_64, .{ .name = "__multi3", .linkage = common.linkage });
+        @export(__multi3_windows_x86_64, .{ .name = "__multi3", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__multi3, .{ .name = "__multi3", .linkage = common.linkage });
+        @export(__multi3, .{ .name = "__multi3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/mulxc3.zig b/lib/compiler_rt/mulxc3.zig
index 4a90d0e45306..8d836ef04d71 100644
--- a/lib/compiler_rt/mulxc3.zig
+++ b/lib/compiler_rt/mulxc3.zig
@@ -5,7 +5,7 @@ pub const panic = common.panic;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(__mulxc3, .{ .name = "__mulxc3", .linkage = common.linkage });
+        @export(__mulxc3, .{ .name = "__mulxc3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/mulxf3.zig b/lib/compiler_rt/mulxf3.zig
index 353d27c2903f..04213b3a9b89 100644
--- a/lib/compiler_rt/mulxf3.zig
+++ b/lib/compiler_rt/mulxf3.zig
@@ -4,7 +4,7 @@ const mulf3 = @import("./mulf3.zig").mulf3;
 pub const panic = common.panic;
 
 comptime {
-    @export(__mulxf3, .{ .name = "__mulxf3", .linkage = common.linkage });
+    @export(__mulxf3, .{ .name = "__mulxf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __mulxf3(a: f80, b: f80) callconv(.C) f80 {
diff --git a/lib/compiler_rt/negXi2.zig b/lib/compiler_rt/negXi2.zig
index 086f80c6b39c..df0ddf94097d 100644
--- a/lib/compiler_rt/negXi2.zig
+++ b/lib/compiler_rt/negXi2.zig
@@ -13,9 +13,9 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__negsi2, .{ .name = "__negsi2", .linkage = common.linkage });
-    @export(__negdi2, .{ .name = "__negdi2", .linkage = common.linkage });
-    @export(__negti2, .{ .name = "__negti2", .linkage = common.linkage });
+    @export(__negsi2, .{ .name = "__negsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__negdi2, .{ .name = "__negdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__negti2, .{ .name = "__negti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __negsi2(a: i32) callconv(.C) i32 {
diff --git a/lib/compiler_rt/negdf2.zig b/lib/compiler_rt/negdf2.zig
index c730ada7e048..25f27a0a1ed2 100644
--- a/lib/compiler_rt/negdf2.zig
+++ b/lib/compiler_rt/negdf2.zig
@@ -4,9 +4,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_dneg, .{ .name = "__aeabi_dneg", .linkage = common.linkage });
+        @export(__aeabi_dneg, .{ .name = "__aeabi_dneg", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__negdf2, .{ .name = "__negdf2", .linkage = common.linkage });
+        @export(__negdf2, .{ .name = "__negdf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/neghf2.zig b/lib/compiler_rt/neghf2.zig
index fe55a751d859..feee02afb0c4 100644
--- a/lib/compiler_rt/neghf2.zig
+++ b/lib/compiler_rt/neghf2.zig
@@ -3,7 +3,7 @@ const common = @import("./common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__neghf2, .{ .name = "__neghf2", .linkage = common.linkage });
+    @export(__neghf2, .{ .name = "__neghf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __neghf2(a: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/negsf2.zig b/lib/compiler_rt/negsf2.zig
index 4cb32097ba9e..1b9e10e12ca4 100644
--- a/lib/compiler_rt/negsf2.zig
+++ b/lib/compiler_rt/negsf2.zig
@@ -4,9 +4,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fneg, .{ .name = "__aeabi_fneg", .linkage = common.linkage });
+        @export(__aeabi_fneg, .{ .name = "__aeabi_fneg", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__negsf2, .{ .name = "__negsf2", .linkage = common.linkage });
+        @export(__negsf2, .{ .name = "__negsf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/negtf2.zig b/lib/compiler_rt/negtf2.zig
index c1c1e9780251..46d498ab9733 100644
--- a/lib/compiler_rt/negtf2.zig
+++ b/lib/compiler_rt/negtf2.zig
@@ -3,7 +3,7 @@ const common = @import("./common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__negtf2, .{ .name = "__negtf2", .linkage = common.linkage });
+    @export(__negtf2, .{ .name = "__negtf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __negtf2(a: f128) callconv(.C) f128 {
diff --git a/lib/compiler_rt/negv.zig b/lib/compiler_rt/negv.zig
index 361cd80ee7d5..5a26dc65e61f 100644
--- a/lib/compiler_rt/negv.zig
+++ b/lib/compiler_rt/negv.zig
@@ -8,9 +8,9 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__negvsi2, .{ .name = "__negvsi2", .linkage = common.linkage });
-    @export(__negvdi2, .{ .name = "__negvdi2", .linkage = common.linkage });
-    @export(__negvti2, .{ .name = "__negvti2", .linkage = common.linkage });
+    @export(__negvsi2, .{ .name = "__negvsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__negvdi2, .{ .name = "__negvdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__negvti2, .{ .name = "__negvti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __negvsi2(a: i32) callconv(.C) i32 {
diff --git a/lib/compiler_rt/negxf2.zig b/lib/compiler_rt/negxf2.zig
index 4e8258453bc2..13a6ef2cab09 100644
--- a/lib/compiler_rt/negxf2.zig
+++ b/lib/compiler_rt/negxf2.zig
@@ -3,7 +3,7 @@ const common = @import("./common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__negxf2, .{ .name = "__negxf2", .linkage = common.linkage });
+    @export(__negxf2, .{ .name = "__negxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __negxf2(a: f80) callconv(.C) f80 {
diff --git a/lib/compiler_rt/parity.zig b/lib/compiler_rt/parity.zig
index 2f48a38bffb0..ee6abf162e7e 100644
--- a/lib/compiler_rt/parity.zig
+++ b/lib/compiler_rt/parity.zig
@@ -8,9 +8,9 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__paritysi2, .{ .name = "__paritysi2", .linkage = common.linkage });
-    @export(__paritydi2, .{ .name = "__paritydi2", .linkage = common.linkage });
-    @export(__parityti2, .{ .name = "__parityti2", .linkage = common.linkage });
+    @export(__paritysi2, .{ .name = "__paritysi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__paritydi2, .{ .name = "__paritydi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__parityti2, .{ .name = "__parityti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __paritysi2(a: i32) callconv(.C) i32 {
diff --git a/lib/compiler_rt/popcount.zig b/lib/compiler_rt/popcount.zig
index 803e93f35aae..ddb0b720c7bd 100644
--- a/lib/compiler_rt/popcount.zig
+++ b/lib/compiler_rt/popcount.zig
@@ -13,9 +13,9 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__popcountsi2, .{ .name = "__popcountsi2", .linkage = common.linkage });
-    @export(__popcountdi2, .{ .name = "__popcountdi2", .linkage = common.linkage });
-    @export(__popcountti2, .{ .name = "__popcountti2", .linkage = common.linkage });
+    @export(__popcountsi2, .{ .name = "__popcountsi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__popcountdi2, .{ .name = "__popcountdi2", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__popcountti2, .{ .name = "__popcountti2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __popcountsi2(a: i32) callconv(.C) i32 {
diff --git a/lib/compiler_rt/round.zig b/lib/compiler_rt/round.zig
index 8f4b3903613e..121371fa1721 100644
--- a/lib/compiler_rt/round.zig
+++ b/lib/compiler_rt/round.zig
@@ -14,15 +14,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__roundh, .{ .name = "__roundh", .linkage = common.linkage });
-    @export(roundf, .{ .name = "roundf", .linkage = common.linkage });
-    @export(round, .{ .name = "round", .linkage = common.linkage });
-    @export(__roundx, .{ .name = "__roundx", .linkage = common.linkage });
+    @export(__roundh, .{ .name = "__roundh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(roundf, .{ .name = "roundf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(round, .{ .name = "round", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__roundx, .{ .name = "__roundx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(roundq, .{ .name = "roundf128", .linkage = common.linkage });
+        @export(roundq, .{ .name = "roundf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(roundq, .{ .name = "roundq", .linkage = common.linkage });
-    @export(roundl, .{ .name = "roundl", .linkage = common.linkage });
+    @export(roundq, .{ .name = "roundq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(roundl, .{ .name = "roundl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __roundh(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/shift.zig b/lib/compiler_rt/shift.zig
index e38c3973bc2b..6d711ee55388 100644
--- a/lib/compiler_rt/shift.zig
+++ b/lib/compiler_rt/shift.zig
@@ -7,18 +7,18 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__ashlti3, .{ .name = "__ashlti3", .linkage = common.linkage });
-    @export(__ashrti3, .{ .name = "__ashrti3", .linkage = common.linkage });
-    @export(__lshrti3, .{ .name = "__lshrti3", .linkage = common.linkage });
+    @export(__ashlti3, .{ .name = "__ashlti3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__ashrti3, .{ .name = "__ashrti3", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__lshrti3, .{ .name = "__lshrti3", .linkage = common.linkage, .visibility = common.visibility });
 
     if (common.want_aeabi) {
-        @export(__aeabi_llsl, .{ .name = "__aeabi_llsl", .linkage = common.linkage });
-        @export(__aeabi_lasr, .{ .name = "__aeabi_lasr", .linkage = common.linkage });
-        @export(__aeabi_llsr, .{ .name = "__aeabi_llsr", .linkage = common.linkage });
+        @export(__aeabi_llsl, .{ .name = "__aeabi_llsl", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_lasr, .{ .name = "__aeabi_lasr", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__aeabi_llsr, .{ .name = "__aeabi_llsr", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__ashldi3, .{ .name = "__ashldi3", .linkage = common.linkage });
-        @export(__ashrdi3, .{ .name = "__ashrdi3", .linkage = common.linkage });
-        @export(__lshrdi3, .{ .name = "__lshrdi3", .linkage = common.linkage });
+        @export(__ashldi3, .{ .name = "__ashldi3", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__ashrdi3, .{ .name = "__ashrdi3", .linkage = common.linkage, .visibility = common.visibility });
+        @export(__lshrdi3, .{ .name = "__lshrdi3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index b6d388bf0ade..eb3d64b0c878 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -18,15 +18,15 @@ const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 pub const panic = common.panic;
 
 comptime {
-    @export(__sinh, .{ .name = "__sinh", .linkage = common.linkage });
-    @export(sinf, .{ .name = "sinf", .linkage = common.linkage });
-    @export(sin, .{ .name = "sin", .linkage = common.linkage });
-    @export(__sinx, .{ .name = "__sinx", .linkage = common.linkage });
+    @export(__sinh, .{ .name = "__sinh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sinf, .{ .name = "sinf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sin, .{ .name = "sin", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__sinx, .{ .name = "__sinx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(sinq, .{ .name = "sinf128", .linkage = common.linkage });
+        @export(sinq, .{ .name = "sinf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(sinq, .{ .name = "sinq", .linkage = common.linkage });
-    @export(sinl, .{ .name = "sinl", .linkage = common.linkage });
+    @export(sinq, .{ .name = "sinq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sinl, .{ .name = "sinl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __sinh(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/sincos.zig b/lib/compiler_rt/sincos.zig
index 30a2b55d959c..769c8d83897d 100644
--- a/lib/compiler_rt/sincos.zig
+++ b/lib/compiler_rt/sincos.zig
@@ -10,15 +10,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__sincosh, .{ .name = "__sincosh", .linkage = common.linkage });
-    @export(sincosf, .{ .name = "sincosf", .linkage = common.linkage });
-    @export(sincos, .{ .name = "sincos", .linkage = common.linkage });
-    @export(__sincosx, .{ .name = "__sincosx", .linkage = common.linkage });
+    @export(__sincosh, .{ .name = "__sincosh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sincosf, .{ .name = "sincosf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sincos, .{ .name = "sincos", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__sincosx, .{ .name = "__sincosx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(sincosq, .{ .name = "sincosf128", .linkage = common.linkage });
+        @export(sincosq, .{ .name = "sincosf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(sincosq, .{ .name = "sincosq", .linkage = common.linkage });
-    @export(sincosl, .{ .name = "sincosl", .linkage = common.linkage });
+    @export(sincosq, .{ .name = "sincosq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sincosl, .{ .name = "sincosl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __sincosh(x: f16, r_sin: *f16, r_cos: *f16) callconv(.C) void {
diff --git a/lib/compiler_rt/sqrt.zig b/lib/compiler_rt/sqrt.zig
index 924a8dc9f95d..2ec9c39e0bf1 100644
--- a/lib/compiler_rt/sqrt.zig
+++ b/lib/compiler_rt/sqrt.zig
@@ -7,15 +7,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__sqrth, .{ .name = "__sqrth", .linkage = common.linkage });
-    @export(sqrtf, .{ .name = "sqrtf", .linkage = common.linkage });
-    @export(sqrt, .{ .name = "sqrt", .linkage = common.linkage });
-    @export(__sqrtx, .{ .name = "__sqrtx", .linkage = common.linkage });
+    @export(__sqrth, .{ .name = "__sqrth", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sqrtf, .{ .name = "sqrtf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sqrt, .{ .name = "sqrt", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__sqrtx, .{ .name = "__sqrtx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(sqrtq, .{ .name = "sqrtf128", .linkage = common.linkage });
+        @export(sqrtq, .{ .name = "sqrtf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(sqrtq, .{ .name = "sqrtq", .linkage = common.linkage });
-    @export(sqrtl, .{ .name = "sqrtl", .linkage = common.linkage });
+    @export(sqrtq, .{ .name = "sqrtq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(sqrtl, .{ .name = "sqrtl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __sqrth(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/subdf3.zig b/lib/compiler_rt/subdf3.zig
index 9d62ffe4807f..a7630b6ea2ef 100644
--- a/lib/compiler_rt/subdf3.zig
+++ b/lib/compiler_rt/subdf3.zig
@@ -4,9 +4,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = common.linkage });
+        @export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__subdf3, .{ .name = "__subdf3", .linkage = common.linkage });
+        @export(__subdf3, .{ .name = "__subdf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/subhf3.zig b/lib/compiler_rt/subhf3.zig
index b14da2d79467..f1d648102ba0 100644
--- a/lib/compiler_rt/subhf3.zig
+++ b/lib/compiler_rt/subhf3.zig
@@ -3,7 +3,7 @@ const common = @import("./common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__subhf3, .{ .name = "__subhf3", .linkage = common.linkage });
+    @export(__subhf3, .{ .name = "__subhf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __subhf3(a: f16, b: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/subo.zig b/lib/compiler_rt/subo.zig
index a7dcf258aa25..b3542a9e9d81 100644
--- a/lib/compiler_rt/subo.zig
+++ b/lib/compiler_rt/subo.zig
@@ -10,9 +10,9 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__subosi4, .{ .name = "__subosi4", .linkage = common.linkage });
-    @export(__subodi4, .{ .name = "__subodi4", .linkage = common.linkage });
-    @export(__suboti4, .{ .name = "__suboti4", .linkage = common.linkage });
+    @export(__subosi4, .{ .name = "__subosi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__subodi4, .{ .name = "__subodi4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__suboti4, .{ .name = "__suboti4", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __subosi4(a: i32, b: i32, overflow: *c_int) callconv(.C) i32 {
diff --git a/lib/compiler_rt/subsf3.zig b/lib/compiler_rt/subsf3.zig
index 472bccc899c1..fbc48ead416f 100644
--- a/lib/compiler_rt/subsf3.zig
+++ b/lib/compiler_rt/subsf3.zig
@@ -4,9 +4,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fsub, .{ .name = "__aeabi_fsub", .linkage = common.linkage });
+        @export(__aeabi_fsub, .{ .name = "__aeabi_fsub", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__subsf3, .{ .name = "__subsf3", .linkage = common.linkage });
+        @export(__subsf3, .{ .name = "__subsf3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/subtf3.zig b/lib/compiler_rt/subtf3.zig
index 4a0d833f57ad..0008905c9446 100644
--- a/lib/compiler_rt/subtf3.zig
+++ b/lib/compiler_rt/subtf3.zig
@@ -4,11 +4,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__subtf3, .{ .name = "__subkf3", .linkage = common.linkage });
+        @export(__subtf3, .{ .name = "__subkf3", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_sub, .{ .name = "_Qp_sub", .linkage = common.linkage });
+        @export(_Qp_sub, .{ .name = "_Qp_sub", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__subtf3, .{ .name = "__subtf3", .linkage = common.linkage });
+    @export(__subtf3, .{ .name = "__subtf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __subtf3(a: f128, b: f128) callconv(.C) f128 {
diff --git a/lib/compiler_rt/subxf3.zig b/lib/compiler_rt/subxf3.zig
index a143f10ffe67..5b3680c2c55e 100644
--- a/lib/compiler_rt/subxf3.zig
+++ b/lib/compiler_rt/subxf3.zig
@@ -4,7 +4,7 @@ const common = @import("./common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__subxf3, .{ .name = "__subxf3", .linkage = common.linkage });
+    @export(__subxf3, .{ .name = "__subxf3", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __subxf3(a: f80, b: f80) callconv(.C) f80 {
diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig
index 8b8f8287a3f5..d6ed881afcb2 100644
--- a/lib/compiler_rt/tan.zig
+++ b/lib/compiler_rt/tan.zig
@@ -20,15 +20,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__tanh, .{ .name = "__tanh", .linkage = common.linkage });
-    @export(tanf, .{ .name = "tanf", .linkage = common.linkage });
-    @export(tan, .{ .name = "tan", .linkage = common.linkage });
-    @export(__tanx, .{ .name = "__tanx", .linkage = common.linkage });
+    @export(__tanh, .{ .name = "__tanh", .linkage = common.linkage, .visibility = common.visibility });
+    @export(tanf, .{ .name = "tanf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(tan, .{ .name = "tan", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__tanx, .{ .name = "__tanx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(tanq, .{ .name = "tanf128", .linkage = common.linkage });
+        @export(tanq, .{ .name = "tanf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(tanq, .{ .name = "tanq", .linkage = common.linkage });
-    @export(tanl, .{ .name = "tanl", .linkage = common.linkage });
+    @export(tanq, .{ .name = "tanq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(tanl, .{ .name = "tanl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __tanh(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig
index f600dff61f19..8c66ba69e7f1 100644
--- a/lib/compiler_rt/trunc.zig
+++ b/lib/compiler_rt/trunc.zig
@@ -14,15 +14,15 @@ const common = @import("common.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__trunch, .{ .name = "__trunch", .linkage = common.linkage });
-    @export(truncf, .{ .name = "truncf", .linkage = common.linkage });
-    @export(trunc, .{ .name = "trunc", .linkage = common.linkage });
-    @export(__truncx, .{ .name = "__truncx", .linkage = common.linkage });
+    @export(__trunch, .{ .name = "__trunch", .linkage = common.linkage, .visibility = common.visibility });
+    @export(truncf, .{ .name = "truncf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(trunc, .{ .name = "trunc", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__truncx, .{ .name = "__truncx", .linkage = common.linkage, .visibility = common.visibility });
     if (common.want_ppc_abi) {
-        @export(truncq, .{ .name = "truncf128", .linkage = common.linkage });
+        @export(truncq, .{ .name = "truncf128", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(truncq, .{ .name = "truncq", .linkage = common.linkage });
-    @export(truncl, .{ .name = "truncl", .linkage = common.linkage });
+    @export(truncq, .{ .name = "truncq", .linkage = common.linkage, .visibility = common.visibility });
+    @export(truncl, .{ .name = "truncl", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __trunch(x: f16) callconv(.C) f16 {
diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig
index a2d3bf1402d4..a8ec9bb0a575 100644
--- a/lib/compiler_rt/truncdfhf2.zig
+++ b/lib/compiler_rt/truncdfhf2.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage });
+        @export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage });
+        @export(__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/truncdfsf2.zig b/lib/compiler_rt/truncdfsf2.zig
index 126dfff0fd2e..85a19988afa8 100644
--- a/lib/compiler_rt/truncdfsf2.zig
+++ b/lib/compiler_rt/truncdfsf2.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = common.linkage });
+        @export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__truncdfsf2, .{ .name = "__truncdfsf2", .linkage = common.linkage });
+        @export(__truncdfsf2, .{ .name = "__truncdfsf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/truncsfhf2.zig b/lib/compiler_rt/truncsfhf2.zig
index 403306979ce0..80b78c2452ad 100644
--- a/lib/compiler_rt/truncsfhf2.zig
+++ b/lib/compiler_rt/truncsfhf2.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.gnu_f16_abi) {
-        @export(__gnu_f2h_ieee, .{ .name = "__gnu_f2h_ieee", .linkage = common.linkage });
+        @export(__gnu_f2h_ieee, .{ .name = "__gnu_f2h_ieee", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_aeabi) {
-        @export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = common.linkage });
+        @export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = common.linkage });
+    @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __truncsfhf2(a: f32) callconv(.C) common.F16T {
diff --git a/lib/compiler_rt/trunctfdf2.zig b/lib/compiler_rt/trunctfdf2.zig
index 02be252856a9..6fa089cd410c 100644
--- a/lib/compiler_rt/trunctfdf2.zig
+++ b/lib/compiler_rt/trunctfdf2.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__trunctfdf2, .{ .name = "__trunckfdf2", .linkage = common.linkage });
+        @export(__trunctfdf2, .{ .name = "__trunckfdf2", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_qtod, .{ .name = "_Qp_qtod", .linkage = common.linkage });
+        @export(_Qp_qtod, .{ .name = "_Qp_qtod", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = common.linkage });
+    @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __trunctfdf2(a: f128) callconv(.C) f64 {
diff --git a/lib/compiler_rt/trunctfhf2.zig b/lib/compiler_rt/trunctfhf2.zig
index b764a784559f..e963753950af 100644
--- a/lib/compiler_rt/trunctfhf2.zig
+++ b/lib/compiler_rt/trunctfhf2.zig
@@ -4,7 +4,7 @@ const truncf = @import("./truncf.zig").truncf;
 pub const panic = common.panic;
 
 comptime {
-    @export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage });
+    @export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __trunctfhf2(a: f128) callconv(.C) common.F16T {
diff --git a/lib/compiler_rt/trunctfsf2.zig b/lib/compiler_rt/trunctfsf2.zig
index 88a3668a93f4..62c00a81aa43 100644
--- a/lib/compiler_rt/trunctfsf2.zig
+++ b/lib/compiler_rt/trunctfsf2.zig
@@ -5,11 +5,11 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage });
+        @export(__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
-        @export(_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = common.linkage });
+        @export(_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = common.linkage, .visibility = common.visibility });
     }
-    @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage });
+    @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __trunctfsf2(a: f128) callconv(.C) f32 {
diff --git a/lib/compiler_rt/trunctfxf2.zig b/lib/compiler_rt/trunctfxf2.zig
index 731f58f19205..3c63cd661bc4 100644
--- a/lib/compiler_rt/trunctfxf2.zig
+++ b/lib/compiler_rt/trunctfxf2.zig
@@ -5,7 +5,7 @@ const trunc_f80 = @import("./truncf.zig").trunc_f80;
 pub const panic = common.panic;
 
 comptime {
-    @export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = common.linkage });
+    @export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __trunctfxf2(a: f128) callconv(.C) f80 {
diff --git a/lib/compiler_rt/truncxfdf2.zig b/lib/compiler_rt/truncxfdf2.zig
index 2b8eaaab8c29..059db73ef682 100644
--- a/lib/compiler_rt/truncxfdf2.zig
+++ b/lib/compiler_rt/truncxfdf2.zig
@@ -4,7 +4,7 @@ const trunc_f80 = @import("./truncf.zig").trunc_f80;
 pub const panic = common.panic;
 
 comptime {
-    @export(__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = common.linkage });
+    @export(__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __truncxfdf2(a: f80) callconv(.C) f64 {
diff --git a/lib/compiler_rt/truncxfhf2.zig b/lib/compiler_rt/truncxfhf2.zig
index 75fdd178412e..80a0dd69febc 100644
--- a/lib/compiler_rt/truncxfhf2.zig
+++ b/lib/compiler_rt/truncxfhf2.zig
@@ -4,7 +4,7 @@ const trunc_f80 = @import("./truncf.zig").trunc_f80;
 pub const panic = common.panic;
 
 comptime {
-    @export(__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = common.linkage });
+    @export(__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __truncxfhf2(a: f80) callconv(.C) common.F16T {
diff --git a/lib/compiler_rt/truncxfsf2.zig b/lib/compiler_rt/truncxfsf2.zig
index 57c0cb7bdf78..8185c5089a4d 100644
--- a/lib/compiler_rt/truncxfsf2.zig
+++ b/lib/compiler_rt/truncxfsf2.zig
@@ -4,7 +4,7 @@ const trunc_f80 = @import("./truncf.zig").trunc_f80;
 pub const panic = common.panic;
 
 comptime {
-    @export(__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = common.linkage });
+    @export(__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __truncxfsf2(a: f80) callconv(.C) f32 {
diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig
index 3f541f00e5e3..e57b5e4d0490 100644
--- a/lib/compiler_rt/udivmodei4.zig
+++ b/lib/compiler_rt/udivmodei4.zig
@@ -7,8 +7,8 @@ const shl = std.math.shl;
 const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max supported type is u65535
 
 comptime {
-    @export(__udivei4, .{ .name = "__udivei4", .linkage = common.linkage });
-    @export(__umodei4, .{ .name = "__umodei4", .linkage = common.linkage });
+    @export(__udivei4, .{ .name = "__udivei4", .linkage = common.linkage, .visibility = common.visibility });
+    @export(__umodei4, .{ .name = "__umodei4", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 const endian = builtin.cpu.arch.endian();
diff --git a/lib/compiler_rt/udivmodti4.zig b/lib/compiler_rt/udivmodti4.zig
index 5ccaa787078f..29523fc6e895 100644
--- a/lib/compiler_rt/udivmodti4.zig
+++ b/lib/compiler_rt/udivmodti4.zig
@@ -7,9 +7,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__udivmodti4_windows_x86_64, .{ .name = "__udivmodti4", .linkage = common.linkage });
+        @export(__udivmodti4_windows_x86_64, .{ .name = "__udivmodti4", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__udivmodti4, .{ .name = "__udivmodti4", .linkage = common.linkage });
+        @export(__udivmodti4, .{ .name = "__udivmodti4", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/udivti3.zig b/lib/compiler_rt/udivti3.zig
index 094627ad92d1..748e9b6599cf 100644
--- a/lib/compiler_rt/udivti3.zig
+++ b/lib/compiler_rt/udivti3.zig
@@ -7,9 +7,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__udivti3_windows_x86_64, .{ .name = "__udivti3", .linkage = common.linkage });
+        @export(__udivti3_windows_x86_64, .{ .name = "__udivti3", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__udivti3, .{ .name = "__udivti3", .linkage = common.linkage });
+        @export(__udivti3, .{ .name = "__udivti3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/umodti3.zig b/lib/compiler_rt/umodti3.zig
index a9aba96b7e4f..097f9a38558a 100644
--- a/lib/compiler_rt/umodti3.zig
+++ b/lib/compiler_rt/umodti3.zig
@@ -7,9 +7,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(__umodti3_windows_x86_64, .{ .name = "__umodti3", .linkage = common.linkage });
+        @export(__umodti3_windows_x86_64, .{ .name = "__umodti3", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__umodti3, .{ .name = "__umodti3", .linkage = common.linkage });
+        @export(__umodti3, .{ .name = "__umodti3", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/unorddf2.zig b/lib/compiler_rt/unorddf2.zig
index 66910a18bfc3..a185b431553b 100644
--- a/lib/compiler_rt/unorddf2.zig
+++ b/lib/compiler_rt/unorddf2.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = common.linkage });
+        @export(__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__unorddf2, .{ .name = "__unorddf2", .linkage = common.linkage });
+        @export(__unorddf2, .{ .name = "__unorddf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/unordhf2.zig b/lib/compiler_rt/unordhf2.zig
index 0c2aea629a16..65d6ed76173b 100644
--- a/lib/compiler_rt/unordhf2.zig
+++ b/lib/compiler_rt/unordhf2.zig
@@ -4,7 +4,7 @@ const comparef = @import("./comparef.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__unordhf2, .{ .name = "__unordhf2", .linkage = common.linkage });
+    @export(__unordhf2, .{ .name = "__unordhf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __unordhf2(a: f16, b: f16) callconv(.C) i32 {
diff --git a/lib/compiler_rt/unordsf2.zig b/lib/compiler_rt/unordsf2.zig
index 78b388a75ec3..e28ad0091c9c 100644
--- a/lib/compiler_rt/unordsf2.zig
+++ b/lib/compiler_rt/unordsf2.zig
@@ -5,9 +5,9 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_aeabi) {
-        @export(__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = common.linkage });
+        @export(__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = common.linkage, .visibility = common.visibility });
     } else {
-        @export(__unordsf2, .{ .name = "__unordsf2", .linkage = common.linkage });
+        @export(__unordsf2, .{ .name = "__unordsf2", .linkage = common.linkage, .visibility = common.visibility });
     }
 }
 
diff --git a/lib/compiler_rt/unordtf2.zig b/lib/compiler_rt/unordtf2.zig
index e00d9cc6d14d..2f9898268309 100644
--- a/lib/compiler_rt/unordtf2.zig
+++ b/lib/compiler_rt/unordtf2.zig
@@ -5,12 +5,12 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__unordtf2, .{ .name = "__unordkf2", .linkage = common.linkage });
+        @export(__unordtf2, .{ .name = "__unordkf2", .linkage = common.linkage, .visibility = common.visibility });
     } else if (common.want_sparc_abi) {
         // These exports are handled in cmptf2.zig because unordered comparisons
         // are based on calling _Qp_cmp.
     }
-    @export(__unordtf2, .{ .name = "__unordtf2", .linkage = common.linkage });
+    @export(__unordtf2, .{ .name = "__unordtf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 fn __unordtf2(a: f128, b: f128) callconv(.C) i32 {
diff --git a/lib/compiler_rt/unordxf2.zig b/lib/compiler_rt/unordxf2.zig
index e4560963706d..d0932f253d92 100644
--- a/lib/compiler_rt/unordxf2.zig
+++ b/lib/compiler_rt/unordxf2.zig
@@ -4,7 +4,7 @@ const comparef = @import("./comparef.zig");
 pub const panic = common.panic;
 
 comptime {
-    @export(__unordxf2, .{ .name = "__unordxf2", .linkage = common.linkage });
+    @export(__unordxf2, .{ .name = "__unordxf2", .linkage = common.linkage, .visibility = common.visibility });
 }
 
 pub fn __unordxf2(a: f80, b: f80) callconv(.C) i32 {

From 4bffe645c6e621cdda858f9eeb4436980fece25c Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Wed, 28 Dec 2022 14:59:53 +0100
Subject: [PATCH 4/5] std: remove hack in test step

This hack was initially introduced as we would export all symbols
unconditionally, including non-function definitions. This would cause
an error from the Wasmtime runtime engine, which this flag would
suppress. As we now properly export symbols, this flag is no longer
needed and any user running into this error can manually include it.

This commit also adds the `--import-symbols` ability to build.zig
---
 lib/std/build/LibExeObjStep.zig | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/lib/std/build/LibExeObjStep.zig b/lib/std/build/LibExeObjStep.zig
index f992fa0c1eb6..0b30d138e8c2 100644
--- a/lib/std/build/LibExeObjStep.zig
+++ b/lib/std/build/LibExeObjStep.zig
@@ -74,6 +74,9 @@ disable_sanitize_c: bool,
 sanitize_thread: bool,
 rdynamic: bool,
 import_memory: bool = false,
+/// For WebAssembly targets, this will allow for undefined symbols to
+/// be imported from the host environment.
+import_symbols: bool = false,
 import_table: bool = false,
 export_table: bool = false,
 initial_memory: ?u64 = null,
@@ -1458,6 +1461,9 @@ fn make(step: *Step) !void {
     if (self.import_memory) {
         try zig_args.append("--import-memory");
     }
+    if (self.import_symbols) {
+        try zig_args.append("--import-symbols");
+    }
     if (self.import_table) {
         try zig_args.append("--import-table");
     }
@@ -1609,8 +1615,6 @@ fn make(step: *Step) !void {
                     try zig_args.append(bin_name);
                     try zig_args.append("--test-cmd");
                     try zig_args.append("--dir=.");
-                    try zig_args.append("--test-cmd");
-                    try zig_args.append("--allow-unknown-exports"); // TODO: Remove when stage2 is default compiler
                     try zig_args.append("--test-cmd-bin");
                 } else {
                     try zig_args.append("--test-no-exec");

From 8403612adc67d6398b3664b20eb453475688bd46 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Wed, 28 Dec 2022 16:36:46 +0100
Subject: [PATCH 5/5] test/link: update linker tests

Force importing symbols to show the correct functions are being
imported from the host environment.
---
 src/link/Wasm.zig                      | 2 +-
 test/link/wasm/extern-mangle/build.zig | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 7bc09c137caa..9beb40e41807 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -3443,7 +3443,7 @@ fn linkWithLLD(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Node) !
             try argv.append("--no-entry"); // So lld doesn't look for _start.
         }
         if (wasm.base.options.import_symbols) {
-            try argv.appendSlice(&[_][]const u8{"--allow-undefined"});
+            try argv.append("--allow-undefined");
         }
         try argv.appendSlice(&[_][]const u8{
             "-o",
diff --git a/test/link/wasm/extern-mangle/build.zig b/test/link/wasm/extern-mangle/build.zig
index f2916c35a7fc..ae46117f1868 100644
--- a/test/link/wasm/extern-mangle/build.zig
+++ b/test/link/wasm/extern-mangle/build.zig
@@ -10,6 +10,8 @@ pub fn build(b: *Builder) void {
     const lib = b.addSharedLibrary("lib", "lib.zig", .unversioned);
     lib.setBuildMode(mode);
     lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    lib.import_symbols = true; // import `a` and `b`
+    lib.rdynamic = true; // export `foo`
     lib.install();
 
     const check_lib = lib.checkObject(.wasm);