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 b385fa5f72baf7f94258acb297d25c18d1715c05..ab91e3cbb3d662aed38afd2e55bd915e5bc99d69 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 450763ac18af6d2930be0703858d61f218d18002..1dadacc2fe23e8209e7c8d5df04f4dfff6492c4f 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 346c92ebbef17dd8b541adb18321651524e57e4d..1f929da150d55dd3f57c87ef8aa110c2db369d96 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 ec0eb74e9338f30f0fc9dc8a7b79afe1739de422..d9cc147604dabfb9897ad0a7114c7c86eb2f8e6d 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,
-- 
2.54.0


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 ab91e3cbb3d662aed38afd2e55bd915e5bc99d69..5b80e5c7a77b9f91979bbdbad1e128d732647a90 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 1f929da150d55dd3f57c87ef8aa110c2db369d96..7bc09c137caad3456cb045a16646f0600f1ad240 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.
-- 
2.54.0


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

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

diff --git a/lib/compiler_rt/absvdi2.zig b/lib/compiler_rt/absvdi2.zig
index 7ebf561ae5aac02a9d49047469b575e1f77f6143..14cd1d83932a99dc62ef4b8c640d45c8aac82826 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 664925f8f9844a4258f3dbbc3bfbbc4c1e9e4ce5..9ca9297c56272f1088ecff43f44af3d9005090da 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 f7d0f796b0b59f2dfce6070a5ce3014d107b9e01..f866f4c2c1e4375e157d54abbc275c2997505b1d 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 1b511f78a4e988dfe6ae453037d3fc187cdff24b..10ae9c328a8229508bae1924b8ff264fa278c743 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 12086aef38e79d79fabf5b97d4514a4b2732ed45..013c2ea714b5a625586c3d26462107b25f39cd2f 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 d14fe36710898a0c9b2ee13322ac850bcb0769af..5248dfb8b86bbd05995e9fbe750ed2b96df97e10 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 83f8285371bcf1a3f55cddc5df1d28218ab73b13..59e96da432f0c2b3041f32a7a7db45226f36e5be 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 15c450e193d5e70e94c79ba4310870c4da14f4b8..e9a077fad51aaefda1986851de8fd86b9a315b68 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 72cf95563235abffc1be0d0e849c8cf92326b4d4..babb11ab801310a1fd2b5b40c65b825feb943e2a 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 145d3992f79eab950ecca8368928f3a41f02d285..27667d3b6095841f33203e23a046518e4b577d62 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 13ca3a7197728b139f02c1f4e69d761c3a425a7a..73bf3fa03ba008c60f5620e3cac8dd4d467a6d8a 100644
--- a/lib/compiler_rt/atomics.zig
+++ b/lib/compiler_rt/atomics.zig
@@ -1,9 +1,11 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const common = @import("./common.zig");
 const cpu = builtin.cpu;
 const arch = cpu.arch;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
+const linkage = common.linkage;
+const visibility = common.visibility;
+pub const panic = common.panic;
 
 // This parameter is true iff the target architecture supports the bare minimum
 // to implement the atomic load/store intrinsics.
@@ -454,59 +456,59 @@ fn __atomic_fetch_nand_8(ptr: *u64, val: u64, model: i32) callconv(.C) u64 {
 
 comptime {
     if (supports_atomic_ops and builtin.object_format != .c) {
-        @export(__atomic_load, .{ .name = "__atomic_load", .linkage = linkage });
-        @export(__atomic_store, .{ .name = "__atomic_store", .linkage = linkage });
-        @export(__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage });
-        @export(__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage });
-
-        @export(__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage });
-        @export(__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage });
-        @export(__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage });
-        @export(__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage });
-
-        @export(__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage });
-        @export(__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage });
-        @export(__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage });
-        @export(__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage });
-
-        @export(__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage });
-        @export(__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage });
-        @export(__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage });
-        @export(__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage });
-
-        @export(__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage });
-        @export(__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage });
-        @export(__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage });
-        @export(__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage });
-
-        @export(__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage });
-        @export(__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage });
-        @export(__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage });
-        @export(__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage });
-
-        @export(__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage });
-        @export(__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage });
-        @export(__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage });
-        @export(__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage });
-
-        @export(__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage });
-        @export(__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage });
-        @export(__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage });
-        @export(__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage });
-
-        @export(__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage });
-        @export(__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage });
-        @export(__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage });
-        @export(__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage });
-
-        @export(__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage });
-        @export(__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage });
-        @export(__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage });
-        @export(__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage });
-
-        @export(__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage });
-        @export(__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage });
-        @export(__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage });
-        @export(__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage });
+        @export(__atomic_load, .{ .name = "__atomic_load", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store, .{ .name = "__atomic_store", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage, .visibility = visibility });
+
+        @export(__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage, .visibility = visibility });
+        @export(__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage, .visibility = visibility });
     }
 }
diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig
index 3443e6ca092110126ecd3813771b934f001f18d9..6c7d90f948a49d531471ab7649284ffab214e781 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 6960e1ecebca936a3352c7d0fb7a87195c40e548..63a35e518f35767838cfdd35891328ac29a7a8d0 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 add6858ffefc20f66933d6529bb25aad70c53f68..bc8d43b48e89443af07f177af08b6446994a7031 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 9f7d2cb879f86899e28b655de209f123a7c41f2a..ed330810f0cebebc6f1d912904a3e53a99d83a66 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 6622546501047775a9594de60f1b592e920b77de..2765ed9f741cf76b83c3ff52fa5067bccfd8db7e 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 8ff2c38cd497d6aded69fb23c97fc69a5f02d4cc..cebc38c2ae4873e2660eb56f8ee2af5ee94f7cb1 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 67dbcd8b4d61759a9b073b28f382955d6b14c074..8a7b37c2c9f058c2751323685e359a2dad038f16 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 d5ee3f1daa15e17ab7a7d3fc7923c448186214a1..d801b30ff6e39cca787b8a06e493d16e33bbbadc 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 1ac40ef6e2cb6e7482f7c260667bef95ade11666..35e250e8109f04080d63cebf281fd5a53cac1503 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 98137e3dfcdb4a115cf998c61e6936f84b9788c6..bc53afc625310f94d3f4858e1780385c81932ae5 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 7286316f99c773d725ce9155a561a8b3bc10e4ba..75355775bbd7ca5eff0ee89d4d9710fd7163f796 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 f16ecf0e188ab545d73f8845afdcb84f5e2bb0ac..40a770070dac2c7e3535bded89c9cde0e5459c3a 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 664f6550a4ed431a14c5d17ca5c197c75ac7ca20..029b6c346a3dd23c3582d6558abd9cdd36cd952e 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 d763e5c8a3296d40058ebd94cffcad1a5704371b..e1500d01026766479cfd2454c995be82fe67d0ce 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 8aad682e6196f86799884c09a2352006415d0f6c..ddcb0b83ea493ff3695b2292f46c7ff06c810be8 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 dd22f4836cc4681e69bfdc6295e26a1cd8a713bc..2f83d312dcc101f29e524de87c83df460f366f30 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 3de89675933247966e6b5c991e504da2907b36e2..7e9bfeb0fff8bd051727a9e52d5d98ce2df626eb 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 ad73a5ddb2710b92e4e539c6606a7a021d21a8e8..6bb607bef935b07c530e29a06130ccb40f812edc 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 c9e0c0cbf567e14179958030cdd0999e9548c0d7..20cdc56a09197dfdc940f4f5ac006e0b6a959e59 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 13565f9b6424fc6645fe9c4a2919eaa43f2adeae..5f051416104bf2e524cd8102ba23190adcea2c96 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 e2382a1372beac68b9d57f637ea2da72d9d7c383..d5b1d1205996aaf677451a2e242845fe25dc44b2 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 736068e81977c74c5a84997eb4a57b72f783e5a0..511a9582a3bd4937d994efcc1f5de4db9829d68a 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 6899cd323f59c71f18c63e8feb2cfac03b46bd56..cd38d7a93e85b29f45c3f5942298ee4abc42fa3d 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 c6ed5a210c6e653b5467f7bf7cd6bba098a867e4..177e26cfd847635757b6583046a2479b75b2a471 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 2282c2129902b147ea3cb6b2094560b325785156..18fd20b726bcdc69735ce42432fd09e153beafef 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 57d495d8bd7deeb4767fd70114c34291afcbb2df..4b37e6dcfc7535acd095d14f65e1d35b1cc3266f 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 7dfac7328ca817215b421f5714aa1cbaf3e23fe6..24d29ad0bba45af46104426d60a7c07eefb964bd 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 daca339baecc1de078a06f0152274c0a01720110..188236752244b098d55b6a4ff7ed61426a4f6c3d 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 3005987530795d9635a2a58936bc3136701622b5..e7b2d8ed705b6758c3f7f242e9e342db19508ec1 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 380a7de4a43110ee23e752489d8d60391b914b3a..c9e10d57ecec7ab36158e7f790734dfd25fa3da0 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 f7a94f58efe0a8e764542c3c22a792076478c74f..97311b104c6daca1c8b48046c500a65cb0933e11 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 f019b42cb622905047f4e2f87eb397fc9d76fd0c..41d9282e8ae3e2efef411d04d2950192efd27794 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 5d339fabce8c94e9415752aa4413d06d26d724a8..2d6307af350606ad2cbffd155a05a84fc73bda10 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 e509f965756008e97a3e3edef4d66f2dcebcb2c8..1f9c43328f200c6e100ee303fdb2b887ed194a09 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 7fd69f6c2252fce7e02def549306590f161c0d43..0a7ba8df531ddc681db214b5c3b391b15e196acf 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 68b07470423a61b5130e20df5bcd0d755bb1c3dc..a74319745a3e6e5a8fd60d971b47660176fe0e5f 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 41bb5ace852aab7bc603e4ca085f768ff7b1d410..938e65c1bd71df6488d0a2cf2426417445eeeffd 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 077d510646439302535afeeae8bf22de64424498..c3243d3018b71af40e0cce6566fbae5e2df5449e 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 e9ce98bb7aa292eef3d010a15abe3cb2974f4969..b38e15e593bbee3b76121262bbda291e6364a07f 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 5935f2352416913d3c3b57fd2a45465e5d520b24..0329b3cc13b047dfcdfd9dde09109ec5fe0b3990 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 983c84ccb141c3190e3fc44449dac9a3569e420c..74406171b4b538999ca23cfc85142f89766c9bd8 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 532b27107208a4935e1a5954557938db9afab73a..ecb4e8912c97113c54a736e3d02c4c6471e047ab 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 28e871f495b16bde5f5602049da73101907f100b..3cb1186d7109e05f0e8a6eade301b27dcaef10ff 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 23440eea22e9c5d82d88c1b8f672a0c5bcd5f195..2f24649fb7b86e5c7090a1f29cd84cb0ae309e86 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 b6774968ddc377896606479ee2f410812881194a..2865bcad295597db8931cf302cde769ee942ba37 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 0c4fb7f3f60d238db11ec57cb3eafe71978a4a12..4bb63e67685178fbd793a53aa8db4c209468ee98 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 f48e354cd270fe9882689eb5242a454f4c5f2b4d..55eb6e227614dd119a71ab2d419b4d03ad1e97ef 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 5aa4068b62656b910e3287fc0e35d8ca390dab7f..cd5e524b20416b2aacb6e90341b1a31accd7f394 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 f9a32828f18c04c6e423eb3ba5937de6afbd033f..bafcf6d83a87b3742542e14c76f1837b9df1d43b 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 0f5e3924ae3d12d0bd41039618e96f85657347b7..389f2b117f47ee08bca812692ba1361e6d19f04c 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 ba46eb85980a7222d936f971eea2e5dd73b526e3..03d861f92e3c19709f94a0f8e27d8a5a1b01f0ee 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 edc0806405ba00db735f41cb11f8ad7de0fa86c0..b544595c7f7031199a0f72f7ba60915828905858 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 cc413f3983d0f0706bbc08a71575a0568b212b8d..87affbce329c63e0e5f29772fa8ed396b5d8e8fc 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 00a89ba2d6f0f920afa5de833841345331bd1635..242d84176b450f3733d8a24d46438fe4935640fe 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 5058bc5e688db8b050cd7d4b074e1ec705241440..9c70df3d5eaa83b5fb65a6a17ee8173125b506cb 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 5755048814e2d5607f0f56c3812c2477f9a52b95..e5070f7a1b29e81a35ef25d66a8e179764b482fa 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 4f5179bfb5bf0c5051054c287bace1feca3dbe15..f7dcb3f7907e704d90e8e50c31a72448478f08c0 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 544dfcd97ed031b812a7951ff2b107c38115132c..dd883693a7e9331d21c7bba72dbfc0e93a5f8527 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 24b1e8669419fe7c4be010008ec9290563cc49f4..a071e674ae22fda948ce9bd9348bb20f06346f36 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 0d3fa5d3b96526866f210370b4c310286062b496..ae2a27ab8e8321aac1568451d06683c787d94ae8 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 fb9ff5b330382d2f7629dcce14c5639d8feda728..710207b330dcd2c5b7f8596c4cb3f2daf83bd75d 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 79cacbe34062a28435c857eb606b272b4d710760..1b0b64c193a4a48fb4d28e64fbe51078d16e89fe 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 02cabd4d46bb966555f002ddbe3372e88aecc036..72b529e0c90a4045b9b8ec216087daa8fb4da998 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 cb2760af4e77597d983db4c4d5fc0a856d4df721..de1cd138062f98a89a3ea3ff50a2da3b765486d7 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 bec36abbf4f87f2dd87acdb45cbdd6dbcaa6a12a..93cdcb2bab8e1736a50a8a15f47cd3fad2f3e18b 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 1cf5891f92cebcfeade357040b6558aac1ac7999..a34bd288c0983348bf3aec4726662d46f6d01a21 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 0f249e0a9218e7af75eabe3589deb0830b4495d6..096e381629b5924d4bdb8276d40781234cb338f1 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 ac2158b7b8cc596e8163595f6dc52aea5d9f584c..b6714d20663bd4718f6f528cd5c06095205d0108 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 9a40ec3d6a136e71e72b4f20e0d0ca34e80330de..2e9dbdc2fbc6aec34786cf512f4b94697641a3af 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 9117e2189dc7ccb390eae736a6f01e49e7f2aa6c..9b9df4ae7016ca2b58c60d32b81e34e544976864 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 f2f7236d6f42efa284194b387b64347d59b24818..1db7a0eac670fc377c655ec12ba14d46cd10f7e6 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 3de94c5103d231a6bb6ed67e5cfd8841934c4cec..3bdcc60f20fdcc23f62329dc5f6eb654334846b1 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 1f651b817b53a381d7b85bb8d3d6911c1135cc26..173dd79f753e29b745e2f66de00cd5e546180a29 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 7d80fdbeb8983fedde9294a92a777a91b161769b..c4fc9ca28f9f8082c3fb105b4c56842c778ced02 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 e31c2616fd1eed67f51b2480883bbb88be5df347..7ec7d90fbada19e89dfe1c2de151feb19941313f 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 84b54298b5ecacec1638540f152455bdb19199ee..0a08c19847e1699d0e6581ac00e7efd3f34d7835 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 87f83315c17bf47df4768d17a7d0bfcda73d11da..daddfb06e154047a6929239d1c68bf225fa08ea5 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 20473fa1d03a813c846ca17e1f4cef5b002f6533..9739b912803c95c1c226fe52ec68150989838966 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 76d266e17a0aa576a837edabb185f8d61734caa2..a9d3709911eb1964deafa447a503d4e4f05efe51 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 31456948e9d8ef1b58c68bb97f51257b10d6b2ea..d70fedbfc3013bcf6b07c48c26e020ce2ad5a758 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 3e33a0bd8a45ca6a1346c37050437e5c4c7d2867..f90a57d1e0ba58284b3adc147b2579bc1edea3df 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 23ff0d16b402aefd7dc8202034ccae2c9581918f..737e1ec409503292c4011f5e6af625586271ed8f 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 c44473cc3d5058d384ed5288aab22c4e7e2814e7..62c215c986ff098a025a5aa68bd352a7eeb97195 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 814880b9ab662a4494d3523418ebd3f67397c921..1af4f83965fb6f12fbb08ab9b60dcc43d9d78414 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 d49575639ed4d1655c282925ce92c68f5e444d7e..db4cc6505e1f9ba0eba0dc86a8f7e1117f6b4d34 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 6eff8aaec3a3759262964f906495c774ca3d6544..e6c6a79d5e7260df2cbee7647fd31fca0a975814 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 963670d85bd4490ee0cf1bff617ca5452a4d9fa1..eb17c0f657de46f4f41bff416b299faa2006671c 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 9236f4705f1fda1805b39240822daa8007ffc60b..0bfa36d6e185a9283e8a6f439a47744fca43f73c 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 331b74df4f83c127e81a61c5b490f1d6283a9c4b..22f885167f32e9d747440fa3d93e2d6d7761aae9 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 1f5a47287a0dc431d62a8b4b20584c526712f9e3..ef5bce2afaefb9c992fc7a12e8f24c1463224576 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 b2f679c18c3de55df2adc116c85d0f63af703b18..0b43d61f4cc215e9941c0b990c7d5ebf0e859f41 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 46f336a4d8b98136a66c52dedb32c23b99dfd46b..f85d1bb013713aab855171c4be7acb4d4dabbc48 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 af454e1e028d555ef07a14aa0923648525ba57bf..ef9593cdf600aa0e1de55f3643df4f601a979923 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 40492564fcd66f1d0626f6b7f81ffb11f7164b5a..cd402e227ded180a3bf5365fbdd8205a0886b734 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 a00175d9a9f2269444236391c7ec29e114ab59ee..d3a685a1ce16fc1c332fb5f141fccdb8530bdf37 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 3cf7a32d270c8670c590a4e552330b1839fe1af0..9102960e8d700758806de8903434fa268dcdbf3d 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 997d57293e7d0294328cbb0b75297b6dbe015da4..7ee013339d70157879287d25e95ed3cf2668f70b 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 ee386bc96ba520de95df08eee1ac2025eaf4b072..413d9253d08a2b8d92e167364c3d8d2edd490f63 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 724af9507514247653e060666f154137d79d4883..877203bd223fde9441376e3a1bca0cd77065824e 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 afdc825f9f8353d7cfaf22dac6bc9b6ce7fcbcd9..ea274c0d8295d018af5ec07349280af5ff04b7e9 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 4bde30f50f16f7ef23799c82d59bdba812305e10..fe2da1c99c682d2ada1e2d0e4c174dafe16caaee 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 df7c4a7f2e9e8fa0e2e8480e8a16900092ed24b8..9645b665f309e2261a43171acccc5f3f19ea59b4 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 7565f3a572db967ea1e52c0758da20403c3b4745..6cb7f8544e48c6e7fa64c28987e2abef50b01367 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 e276b9988476699f863eac2dc26ed954ed6a54fc..b80dffdb820b706bd6e767c0d11637f9f33abca0 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 684ba665b52cc3fdc13891c84719319336035959..c887a9b6e4ff01c442a8e77c2971e9bb9162db9d 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 651cbf943f9a9cdb6a9bfb9f8f5bf5eeff34a3e6..e3df4d30874c32cd9370a4853f00e48b60537465 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 3d455e52bfd3668ceec80ad7e7b5839a2f762f30..44439976bbeab462b899eb1fa44b54ca33c62f1a 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 831736250fd161fe747a1f8e86b77014a7a432cb..1a5c06af3d7328686a2fa2f056f53905df162f41 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 6bb88fbb8f4ef7fa2b610b8628cb8a5a55dd9353..bf0b0edccb0706845804c938a7dca95fe4e2549d 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 43bc160cda9fcf84d8c2e5cf98a114ea7773d06a..b844af1859839780bb75c4952c24e25ef25ca6e6 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 5e7085a41bd81c79ab49cbe5b92b4f68d0a87a1d..71d90f7c3a7c54ed24c04391e1b8ac64fc8f9d9b 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 54638cc6458f27cff16a14d9c67b50a342401bd7..5c345ff12f70c40c8d81d60fd61c578ba8862dea 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 8298c3dbe3251c520bfe3e0d9c27b2d8398c163b..612c97859866ca936c1f1ae07dfa5d6e322f55d2 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 6f7e48135b6b9c2ac0c6c90e0553b6ca912a93ad..b337e6f29e43a28249920830462a1acbc2721e0e 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 8f58fe909ca06db00b518b8978afc189f0f4fd79..410117b6c37e1b51dca8c43d2b681f31022a7cc1 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 73d86795291fc396b6f2138ed8670869e344dafd..61ccb1205d2d702cee341fd8fdcb9196c54f94c3 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 e88e74079aa3273ed03cd83a383fcccde668a50b..25c54936071079a8be55b2ed2b85a4d832159ec6 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 9992f716eefdfa16486cf13fab887c45794fc4f6..ef02a697bc81b4983a439b3a00e31e64d9d63f4d 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 cef8f660b20486b5a5b6aa4ae06184511a6eabe1..3a497fdedcc5b35d896bb66ab790fd184bdb3599 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 ef7ab9fbf78dafcc03d4a473b27f2fbc898962b6..81c698938178c86279091ebb75a237b5075a583a 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 a51c6c7b76f0e697c162db37c2a1db0b1da8ec3b..c79713fed0fa8b86caa8e858a8a05a6c1f585bf1 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 70c68e2a72d0ecf03340b7a694865fd38ef179d2..cf44f1cc14ba4f82dfeff16264f95643e4dae9bc 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 45251548bea821ddc6f0474eecd75bd9d18e433b..c38c659092a72cbeddb77fc0825a1fdc09b6bc3b 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 cd2d127c344749ca96f0887f2152c7ea72fe3dd5..13e58a78005cca7d3b368352378aef6d1a2d5e42 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 5fe289453b385ddcec56101b9de940b2cdad2296..add389a598652b24998310d843f474726b0f4cc4 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 3294f5b1c780337170b63191e350c81b78da2767..27d0e09f3403e1de8fa22fee411b1782e0ed4712 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 94f2205d7658361f2e37bd1e07c47cfdb1edbb10..89054e4af8160685d6ef880dd49c14490f98d457 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 878cd5c4ac614f6b9fad68e6743334b1c96a3630..453a869a83b7015d0afef324c26a9cba541ccc29 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 9502dc5677ce125a19acdabe2f4d3a03e0913fa4..1918e8b976d91027c23781d1019276831ef4e7fa 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 4a90d0e45306d93637cad24952e5a3d41236f076..8d836ef04d719eef35ef1fa65ec97c6ef4c9131f 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 353d27c2903feff7ce51c717a540245655b59541..04213b3a9b8952ca6277069252e6f6c4fad7ddea 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 086f80c6b39c9903817ca35a55f59adc85470951..df0ddf94097df352daada600742a45769e772a3a 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 c730ada7e048f1261d63a8d558f063d7b7b41f46..25f27a0a1ed247e4f4310edcc1e976b807601cd2 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 fe55a751d85931098dc22bb89a96781c6a901a12..feee02afb0c43aeef7b6dd540d3ff952e86e8c59 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 4cb32097ba9ed15bd9d5f06d62e31e00acc5c24b..1b9e10e12ca41c6a05654518b91b9d4c1e2dfd2e 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 c1c1e9780251c8527a5fe1fa93c87c38ba160126..46d498ab973366a3bbf1d08f97532466aa11d1ab 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 361cd80ee7d5b502a20c774925b8e2f2b7507adf..5a26dc65e61f00e034f8679dc30e52b276accefa 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 4e8258453bc29943ca35b2a04137e1f70df9234b..13a6ef2cab0938df7d0729ec86fae4f65857a1bc 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 2f48a38bffb032850e0a11f66c85453ce6dcb234..ee6abf162e7ec9bab797bc1d456d9ae2d8be0d22 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 803e93f35aae95bfb8d73b0829c2756a164acd7a..ddb0b720c7bdccdd311a1ec59e3b23655ce6985c 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 8f4b3903613eb26973038289df69f48c5a56131a..121371fa17213a50745dca8d80838d1918312f25 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 e38c3973bc2b09130f962bb85152800f7471b1f0..6d711ee553881ebada4141fad987b290c3e7ac30 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 b6d388bf0adee473f9f5ec149a30ef77d845f3b2..eb3d64b0c878b6b169c357eea017d82bcdc4b828 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 30a2b55d959c2c3b96dcbc1b3743a0ae06f6972b..769c8d83897d839a97ec76046c4178e5e75c4c9b 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 924a8dc9f95dc2377b77f5bb24d5d59d146bf9cb..2ec9c39e0bf121a5e42b1fd5e8999e5d4d587a49 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 9d62ffe4807f2eec8e950a8fcff3dfe7db0bb06b..a7630b6ea2ef02ab014222840fb5b9b7848f82b3 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 b14da2d7946783cc6d29b4146014c1c6fd027033..f1d648102ba006d6edbb464bf4f46b13fc693b3f 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 a7dcf258aa251bfd0bcc8737233fef0201d8ba06..b3542a9e9d810bf330fe554e22a19e81abc6f905 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 472bccc899c1052e1a33c59612e6c8fdd3022956..fbc48ead416fbe469215432fbdc88f6af8ba4713 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 4a0d833f57adbd4e6b1519729520537323bf6bed..0008905c9446f002e0cdc2a9a08d6615f2cbb8cc 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 a143f10ffe6779d1b64d92be3f05b9a832d8506a..5b3680c2c55e8de4094f72191ab0198a1aa2c934 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 8b8f8287a3f5497d020baa9393269d4e591acc9c..d6ed881afcb2e26ea26d80b922eee368af475211 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 f600dff61f1942fa18297333677c645a551b5447..8c66ba69e7f1ca98e963c947f6baf1045a70f03f 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 a2d3bf1402d48d5e846fcd9f116743fa2fd65455..a8ec9bb0a5750103c784573793f057ef8620def4 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 126dfff0fd2e85b23e548ea960e765a212640371..85a19988afa8fe93e3546318a26e4c5d72b11ffb 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 403306979ce06d97d86b50fdc591b7dd0445b151..80b78c2452adbce67d5959d13534daf921688942 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 02be252856a9fcceec29332680d1e2686a9133d9..6fa089cd410c9408a4982e4438ccefbfefdb76a0 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 b764a784559f847d0dfa2fd3136aae8a9f34ffd7..e963753950af2cd993908b1125c4ef2582beb302 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 88a3668a93f48b01e676799806cd7b2161e9cc2d..62c00a81aa438bef613fd0d2cbdf81ec31160865 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 731f58f19205b4fc4f1c5f22dfd351e7637fb7d5..3c63cd661bc4f6afb1f18eec71b5bee11aa40117 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 2b8eaaab8c291dfb847bedb54fc4744010a39742..059db73ef682c0cadf38ed0eefaaf4bd1d1cf656 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 75fdd178412ecae535e74cc9dccb376030ff407f..80a0dd69febcd44a09c952aa0ac4cbcb62cbdd93 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 57c0cb7bdf78c50bc70467011592e18ae890bc72..8185c5089a4d6f87471a9c9a39a9a9eab86ab055 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 3f541f00e5e38f5a2056c3844f7475dd695267e4..e57b5e4d0490afd410f963aecc1b2ce2165ea309 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 5ccaa787078ffdd0741be1b0ca0e65911babbd95..29523fc6e895102ec42b76f93da9c85283f7d66e 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 094627ad92d115216acfb3b3a1333e23e85c55f8..748e9b6599cff922f00002f9703cfa456be54dc0 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 a9aba96b7e4f966a6a538080ec8daa403b82744a..097f9a38558ac88a3c8b6dee2aeaa65d2c840ddb 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 66910a18bfc32143b988770737dfba7fe7f33a46..a185b431553b30d42be6b451135302e569a2a23f 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 0c2aea629a162850e39dbf5bdaadddf52dd8a783..65d6ed76173bc07cff71784b25c2a61723c3cdcf 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 78b388a75ec3c7f4f1ceef15ff732b167bfb4c91..e28ad0091c9cb7321053920a71094dc7000fd539 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 e00d9cc6d14d2d33ca84048bf74c5d039f189b96..2f98982683092ce3a8c317f09effd8b7412a3f11 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 e4560963706ddf762e91e287a29f42149bede25d..d0932f253d92086471e6cb552f1e909774e86f49 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 {
-- 
2.54.0


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 f992fa0c1eb6ec03c3aaa25671dc0bc57daad2bc..0b30d138e8c2a12da22227f1f67ca52ab9519839 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");
-- 
2.54.0


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 7bc09c137caad3456cb045a16646f0600f1ad240..9beb40e418075a3f4648d9619b18f66852bfae91 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 f2916c35a7fcd33c68279be6f956cc008d3da928..ae46117f186891555cc85d29e6646b1d1ccde317 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);
-- 
2.54.0