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 b385fa5f72..ab91e3cbb3 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 450763ac18..1dadacc2fe 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 346c92ebbe..1f929da150 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 ec0eb74e93..d9cc147604 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 ab91e3cbb3..5b80e5c7a7 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 1f929da150..7bc09c137c 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     | 94 +++++++++++++++++----------------
 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, 568 insertions(+), 562 deletions(-)

diff --git a/lib/compiler_rt/absvdi2.zig b/lib/compiler_rt/absvdi2.zig
index 7ebf561ae5..14cd1d8393 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 664925f8f9..9ca9297c56 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 f7d0f796b0..f866f4c2c1 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 1b511f78a4..10ae9c328a 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 12086aef38..013c2ea714 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 d14fe36710..5248dfb8b8 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 83f8285371..59e96da432 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 15c450e193..e9a077fad5 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 72cf955632..babb11ab80 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 145d3992f7..27667d3b60 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 13ca3a7197..73bf3fa03b 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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 });
-        @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_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 3443e6ca09..6c7d90f948 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 6960e1eceb..63a35e518f 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 add6858ffe..bc8d43b48e 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 9f7d2cb879..ed330810f0 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 6622546501..2765ed9f74 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 8ff2c38cd4..cebc38c2ae 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 67dbcd8b4d..8a7b37c2c9 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 d5ee3f1daa..d801b30ff6 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 1ac40ef6e2..35e250e810 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 98137e3dfc..bc53afc625 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 7286316f99..75355775bb 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 f16ecf0e18..40a770070d 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 664f6550a4..029b6c346a 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 d763e5c8a3..e1500d0102 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 8aad682e61..ddcb0b83ea 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 dd22f4836c..2f83d312dc 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 3de8967593..7e9bfeb0ff 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 ad73a5ddb2..6bb607bef9 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 c9e0c0cbf5..20cdc56a09 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 13565f9b64..5f05141610 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 e2382a1372..d5b1d12059 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 736068e819..511a9582a3 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 6899cd323f..cd38d7a93e 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 c6ed5a210c..177e26cfd8 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 2282c21299..18fd20b726 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 57d495d8bd..4b37e6dcfc 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 7dfac7328c..24d29ad0bb 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 daca339bae..1882367522 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 3005987530..e7b2d8ed70 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 380a7de4a4..c9e10d57ec 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 f7a94f58ef..97311b104c 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 f019b42cb6..41d9282e8a 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 5d339fabce..2d6307af35 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 e509f96575..1f9c43328f 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 7fd69f6c22..0a7ba8df53 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 68b0747042..a74319745a 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 41bb5ace85..938e65c1bd 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 077d510646..c3243d3018 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 e9ce98bb7a..b38e15e593 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 5935f23524..0329b3cc13 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 983c84ccb1..74406171b4 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 532b271072..ecb4e8912c 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 28e871f495..3cb1186d71 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 23440eea22..2f24649fb7 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 b6774968dd..2865bcad29 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 0c4fb7f3f6..4bb63e6768 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 f48e354cd2..55eb6e2276 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 5aa4068b62..cd5e524b20 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 f9a32828f1..bafcf6d83a 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 0f5e3924ae..389f2b117f 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 ba46eb8598..03d861f92e 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 edc0806405..b544595c7f 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 cc413f3983..87affbce32 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 00a89ba2d6..242d84176b 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 5058bc5e68..9c70df3d5e 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 5755048814..e5070f7a1b 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 4f5179bfb5..f7dcb3f790 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 544dfcd97e..dd883693a7 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 24b1e86694..a071e674ae 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 0d3fa5d3b9..ae2a27ab8e 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 fb9ff5b330..710207b330 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 79cacbe340..1b0b64c193 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 02cabd4d46..72b529e0c9 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 cb2760af4e..de1cd13806 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 bec36abbf4..93cdcb2bab 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 1cf5891f92..a34bd288c0 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 0f249e0a92..096e381629 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 ac2158b7b8..b6714d2066 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 9a40ec3d6a..2e9dbdc2fb 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 9117e2189d..9b9df4ae70 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 f2f7236d6f..1db7a0eac6 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 3de94c5103..3bdcc60f20 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 1f651b817b..173dd79f75 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 7d80fdbeb8..c4fc9ca28f 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 e31c2616fd..7ec7d90fba 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 84b54298b5..0a08c19847 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 87f83315c1..daddfb06e1 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 20473fa1d0..9739b91280 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 76d266e17a..a9d3709911 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 31456948e9..d70fedbfc3 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 3e33a0bd8a..f90a57d1e0 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 23ff0d16b4..737e1ec409 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 c44473cc3d..62c215c986 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 814880b9ab..1af4f83965 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 d49575639e..db4cc6505e 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 6eff8aaec3..e6c6a79d5e 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 963670d85b..eb17c0f657 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 9236f4705f..0bfa36d6e1 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 331b74df4f..22f885167f 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 1f5a47287a..ef5bce2afa 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 b2f679c18c..0b43d61f4c 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 46f336a4d8..f85d1bb013 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 af454e1e02..ef9593cdf6 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 40492564fc..cd402e227d 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 a00175d9a9..d3a685a1ce 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 3cf7a32d27..9102960e8d 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 997d57293e..7ee013339d 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 ee386bc96b..413d9253d0 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 724af95075..877203bd22 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 afdc825f9f..ea274c0d82 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 4bde30f50f..fe2da1c99c 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 df7c4a7f2e..9645b665f3 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 7565f3a572..6cb7f8544e 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 e276b99884..b80dffdb82 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 684ba665b5..c887a9b6e4 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 651cbf943f..e3df4d3087 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 3d455e52bf..44439976bb 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 831736250f..1a5c06af3d 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 6bb88fbb8f..bf0b0edccb 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 43bc160cda..b844af1859 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 5e7085a41b..71d90f7c3a 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 54638cc645..5c345ff12f 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 8298c3dbe3..612c978598 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 6f7e48135b..b337e6f29e 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 8f58fe909c..410117b6c3 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 73d8679529..61ccb1205d 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 e88e74079a..25c5493607 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 9992f716ee..ef02a697bc 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 cef8f660b2..3a497fdedc 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 ef7ab9fbf7..81c6989381 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 a51c6c7b76..c79713fed0 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 70c68e2a72..cf44f1cc14 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 45251548be..c38c659092 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 cd2d127c34..13e58a7800 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 5fe289453b..add389a598 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 3294f5b1c7..27d0e09f34 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 94f2205d76..89054e4af8 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 878cd5c4ac..453a869a83 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 9502dc5677..1918e8b976 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 4a90d0e453..8d836ef04d 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 353d27c290..04213b3a9b 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 086f80c6b3..df0ddf9409 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 c730ada7e0..25f27a0a1e 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 fe55a751d8..feee02afb0 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 4cb32097ba..1b9e10e12c 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 c1c1e97802..46d498ab97 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 361cd80ee7..5a26dc65e6 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 4e8258453b..13a6ef2cab 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 2f48a38bff..ee6abf162e 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 803e93f35a..ddb0b720c7 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 8f4b390361..121371fa17 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 e38c3973bc..6d711ee553 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 b6d388bf0a..eb3d64b0c8 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 30a2b55d95..769c8d8389 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 924a8dc9f9..2ec9c39e0b 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 9d62ffe480..a7630b6ea2 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 b14da2d794..f1d648102b 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 a7dcf258aa..b3542a9e9d 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 472bccc899..fbc48ead41 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 4a0d833f57..0008905c94 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 a143f10ffe..5b3680c2c5 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 8b8f8287a3..d6ed881afc 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 f600dff61f..8c66ba69e7 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 a2d3bf1402..a8ec9bb0a5 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 126dfff0fd..85a19988af 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 403306979c..80b78c2452 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 02be252856..6fa089cd41 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 b764a78455..e963753950 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 88a3668a93..62c00a81aa 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 731f58f192..3c63cd661b 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 2b8eaaab8c..059db73ef6 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 75fdd17841..80a0dd69fe 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 57c0cb7bdf..8185c5089a 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 3f541f00e5..e57b5e4d04 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 5ccaa78707..29523fc6e8 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 094627ad92..748e9b6599 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 a9aba96b7e..097f9a3855 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 66910a18bf..a185b43155 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 0c2aea629a..65d6ed7617 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 78b388a75e..e28ad0091c 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 e00d9cc6d1..2f98982683 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 e456096370..d0932f253d 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 f992fa0c1e..0b30d138e8 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 7bc09c137c..9beb40e418 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 f2916c35a7..ae46117f18 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);