diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig
index 87ff89c2d937b395eb562b7c82bbe7afb0916917..343363188f9f5023b54a54f145412212c799a840 100644
--- a/lib/compiler_rt.zig
+++ b/lib/compiler_rt.zig
@@ -1,10 +1,11 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("compiler_rt/common.zig");
+const ofmt_c = builtin.object_format == .c;
+
+const std = @import("std");
 
 /// Avoid dragging in the runtime safety mechanisms into this .o file, unless
 /// we're trying to test compiler-rt.
-pub const panic = if (common.test_safety)
+pub const panic = if (test_safety)
     std.debug.FullPanic(std.debug.defaultPanic)
 else
     std.debug.no_panic;
@@ -19,6 +20,33 @@ pub const std_options_debug_io: std.Io = if (builtin.is_test)
 else
     unreachable;
 
+pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void {
+    @export(func, .{ .name = name, .linkage = linkage, .visibility = visibility });
+}
+
+/// For now, we prefer weak linkage because some of the routines we implement here may also be
+/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
+/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883
+pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
+    .internal
+else if (ofmt_c)
+    .strong
+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 (linkage == .internal or builtin.link_mode == .dynamic)
+    .default
+else
+    .hidden;
+
+pub const test_safety = switch (builtin.zig_backend) {
+    .stage2_aarch64 => false,
+    else => builtin.is_test,
+};
+
 comptime {
     // Integer routines
     _ = @import("compiler_rt/count0bits.zig");
@@ -276,17 +304,44 @@ comptime {
         _ = @import("compiler_rt/memcpy.zig");
         _ = @import("compiler_rt/memset.zig");
         _ = @import("compiler_rt/memmove.zig");
-        _ = @import("compiler_rt/memcmp.zig");
+        symbol(&memcmp, "memcmp");
         _ = @import("compiler_rt/bcmp.zig");
         _ = @import("compiler_rt/ssp.zig");
-
-        _ = @import("compiler_rt/strlen.zig");
+        symbol(&strlen, "strlen");
     }
 
     // Temporarily used for uefi until https://github.com/ziglang/zig/issues/21630 is addressed.
     if (!builtin.link_libc and (builtin.os.tag == .windows or builtin.os.tag == .uefi) and (builtin.abi == .none or builtin.abi == .msvc)) {
-        @export(&_fltused, .{ .name = "_fltused", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_fltused, "_fltused");
     }
 }
 
 var _fltused: c_int = 1;
+
+fn strlen(s: [*:0]const c_char) callconv(.c) usize {
+    return std.mem.len(s);
+}
+
+fn memcmp(vl: [*]const u8, vr: [*]const u8, n: usize) callconv(.c) c_int {
+    var i: usize = 0;
+    while (i < n) : (i += 1) {
+        const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]);
+        if (compared != 0) return compared;
+    }
+    return 0;
+}
+
+test "memcmp" {
+    const arr0 = &[_]u8{ 1, 1, 1 };
+    const arr1 = &[_]u8{ 1, 1, 1 };
+    const arr2 = &[_]u8{ 1, 0, 1 };
+    const arr3 = &[_]u8{ 1, 2, 1 };
+    const arr4 = &[_]u8{ 1, 0xff, 1 };
+
+    try std.testing.expect(memcmp(arr0, arr1, 3) == 0);
+    try std.testing.expect(memcmp(arr0, arr2, 3) > 0);
+    try std.testing.expect(memcmp(arr0, arr3, 3) < 0);
+
+    try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
+    try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
+}
diff --git a/lib/compiler_rt/absvdi2.zig b/lib/compiler_rt/absvdi2.zig
index add32608e8a389c6a62139410f356b0c24072981..408d70ad167d29c7895e6145e7635da95ec62a82 100644
--- a/lib/compiler_rt/absvdi2.zig
+++ b/lib/compiler_rt/absvdi2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const absv = @import("./absv.zig").absv;
 
 comptime {
-    @export(&__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__absvdi2, "__absvdi2");
 }
 
 pub fn __absvdi2(a: i64) callconv(.c) i64 {
diff --git a/lib/compiler_rt/absvti2.zig b/lib/compiler_rt/absvti2.zig
index 1b2ddaaefac6ad7fa139a331fe569bcf11f27cc9..ab367d2b78ae2f0a813d011ec74dc532d103303f 100644
--- a/lib/compiler_rt/absvti2.zig
+++ b/lib/compiler_rt/absvti2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const absv = @import("./absv.zig").absv;
 
 comptime {
-    @export(&__absvti2, .{ .name = "__absvti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__absvti2, "__absvti2");
 }
 
 pub fn __absvti2(a: i128) callconv(.c) i128 {
diff --git a/lib/compiler_rt/adddf3.zig b/lib/compiler_rt/adddf3.zig
index 98fba79bbd5116617489d61e32c0d02122f1a579..7a49b0d782b7b50b022fee510f8cc885c567acd5 100644
--- a/lib/compiler_rt/adddf3.zig
+++ b/lib/compiler_rt/adddf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const addf3 = @import("./addf3.zig").addf3;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dadd, "__aeabi_dadd");
     } else {
-        @export(&__adddf3, .{ .name = "__adddf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__adddf3, "__adddf3");
     }
 }
 
diff --git a/lib/compiler_rt/addsf3.zig b/lib/compiler_rt/addsf3.zig
index ef1627ae7ae05d9a83716fa53178b9d50971e040..fb65bec624939a224e5938aabcdc77d821f43e3f 100644
--- a/lib/compiler_rt/addsf3.zig
+++ b/lib/compiler_rt/addsf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const addf3 = @import("./addf3.zig").addf3;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_fadd, "__aeabi_fadd");
     } else {
-        @export(&__addsf3, .{ .name = "__addsf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__addsf3, "__addsf3");
     }
 }
 
diff --git a/lib/compiler_rt/addvdi3.zig b/lib/compiler_rt/addvdi3.zig
index e7346b717ff87faada5d780b02d0b42e1e30d7b6..a5cde2494acba14282409395aa47ce9660faa0ff 100644
--- a/lib/compiler_rt/addvdi3.zig
+++ b/lib/compiler_rt/addvdi3.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const testing = @import("std").testing;
 
 comptime {
-    @export(&__addvdi3, .{ .name = "__addvdi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__addvdi3, "__addvdi3");
 }
 
 pub fn __addvdi3(a: i64, b: i64) callconv(.c) i64 {
diff --git a/lib/compiler_rt/atomics.zig b/lib/compiler_rt/atomics.zig
index b87b7a6315252a277ed7b6d8f6b001f833885ed9..31c87f4b1ba6ab6f6f668952e61770fcbcd641cd 100644
--- a/lib/compiler_rt/atomics.zig
+++ b/lib/compiler_rt/atomics.zig
@@ -1,10 +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 = common.linkage;
-const visibility = common.visibility;
+
+const std = @import("std");
+
+const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 // This parameter is true iff the target architecture supports the bare minimum
 // to implement the atomic load/store intrinsics.
@@ -225,7 +226,7 @@ fn __atomic_store_16(dst: *u128, value: u128, model: i32) callconv(.c) void {
 }
 
 fn wideUpdate(comptime T: type, ptr: *T, val: T, update: anytype) T {
-    const WideAtomic = std.meta.Int(.unsigned, smallest_atomic_fetch_exch_size * 8);
+    const WideAtomic = @Int(.unsigned, smallest_atomic_fetch_exch_size * 8);
 
     const addr = @intFromPtr(ptr);
     const wide_addr = addr & ~(@as(T, smallest_atomic_fetch_exch_size) - 1);
@@ -535,81 +536,81 @@ fn __atomic_fetch_umin_16(ptr: *u128, val: u128, model: i32) callconv(.c) u128 {
 
 comptime {
     if (supports_atomic_ops and builtin.object_format != .c) {
-        @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 });
+        symbol(&__atomic_load, "__atomic_load");
+        symbol(&__atomic_store, "__atomic_store");
+        symbol(&__atomic_exchange, "__atomic_exchange");
+        symbol(&__atomic_compare_exchange, "__atomic_compare_exchange");
 
-        @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_add_16, .{ .name = "__atomic_fetch_add_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_add_1, "__atomic_fetch_add_1");
+        symbol(&__atomic_fetch_add_2, "__atomic_fetch_add_2");
+        symbol(&__atomic_fetch_add_4, "__atomic_fetch_add_4");
+        symbol(&__atomic_fetch_add_8, "__atomic_fetch_add_8");
+        symbol(&__atomic_fetch_add_16, "__atomic_fetch_add_16");
 
-        @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_sub_16, .{ .name = "__atomic_fetch_sub_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_sub_1, "__atomic_fetch_sub_1");
+        symbol(&__atomic_fetch_sub_2, "__atomic_fetch_sub_2");
+        symbol(&__atomic_fetch_sub_4, "__atomic_fetch_sub_4");
+        symbol(&__atomic_fetch_sub_8, "__atomic_fetch_sub_8");
+        symbol(&__atomic_fetch_sub_16, "__atomic_fetch_sub_16");
 
-        @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_and_16, .{ .name = "__atomic_fetch_and_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_and_1, "__atomic_fetch_and_1");
+        symbol(&__atomic_fetch_and_2, "__atomic_fetch_and_2");
+        symbol(&__atomic_fetch_and_4, "__atomic_fetch_and_4");
+        symbol(&__atomic_fetch_and_8, "__atomic_fetch_and_8");
+        symbol(&__atomic_fetch_and_16, "__atomic_fetch_and_16");
 
-        @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_or_16, .{ .name = "__atomic_fetch_or_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_or_1, "__atomic_fetch_or_1");
+        symbol(&__atomic_fetch_or_2, "__atomic_fetch_or_2");
+        symbol(&__atomic_fetch_or_4, "__atomic_fetch_or_4");
+        symbol(&__atomic_fetch_or_8, "__atomic_fetch_or_8");
+        symbol(&__atomic_fetch_or_16, "__atomic_fetch_or_16");
 
-        @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_xor_16, .{ .name = "__atomic_fetch_xor_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_xor_1, "__atomic_fetch_xor_1");
+        symbol(&__atomic_fetch_xor_2, "__atomic_fetch_xor_2");
+        symbol(&__atomic_fetch_xor_4, "__atomic_fetch_xor_4");
+        symbol(&__atomic_fetch_xor_8, "__atomic_fetch_xor_8");
+        symbol(&__atomic_fetch_xor_16, "__atomic_fetch_xor_16");
 
-        @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_fetch_nand_16, .{ .name = "__atomic_fetch_nand_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_nand_1, "__atomic_fetch_nand_1");
+        symbol(&__atomic_fetch_nand_2, "__atomic_fetch_nand_2");
+        symbol(&__atomic_fetch_nand_4, "__atomic_fetch_nand_4");
+        symbol(&__atomic_fetch_nand_8, "__atomic_fetch_nand_8");
+        symbol(&__atomic_fetch_nand_16, "__atomic_fetch_nand_16");
 
-        @export(&__atomic_fetch_umax_1, .{ .name = "__atomic_fetch_umax_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_2, .{ .name = "__atomic_fetch_umax_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_4, .{ .name = "__atomic_fetch_umax_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_8, .{ .name = "__atomic_fetch_umax_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umax_16, .{ .name = "__atomic_fetch_umax_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_umax_1, "__atomic_fetch_umax_1");
+        symbol(&__atomic_fetch_umax_2, "__atomic_fetch_umax_2");
+        symbol(&__atomic_fetch_umax_4, "__atomic_fetch_umax_4");
+        symbol(&__atomic_fetch_umax_8, "__atomic_fetch_umax_8");
+        symbol(&__atomic_fetch_umax_16, "__atomic_fetch_umax_16");
 
-        @export(&__atomic_fetch_umin_1, .{ .name = "__atomic_fetch_umin_1", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_2, .{ .name = "__atomic_fetch_umin_2", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_4, .{ .name = "__atomic_fetch_umin_4", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_8, .{ .name = "__atomic_fetch_umin_8", .linkage = linkage, .visibility = visibility });
-        @export(&__atomic_fetch_umin_16, .{ .name = "__atomic_fetch_umin_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_fetch_umin_1, "__atomic_fetch_umin_1");
+        symbol(&__atomic_fetch_umin_2, "__atomic_fetch_umin_2");
+        symbol(&__atomic_fetch_umin_4, "__atomic_fetch_umin_4");
+        symbol(&__atomic_fetch_umin_8, "__atomic_fetch_umin_8");
+        symbol(&__atomic_fetch_umin_16, "__atomic_fetch_umin_16");
 
-        @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_load_16, .{ .name = "__atomic_load_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_load_1, "__atomic_load_1");
+        symbol(&__atomic_load_2, "__atomic_load_2");
+        symbol(&__atomic_load_4, "__atomic_load_4");
+        symbol(&__atomic_load_8, "__atomic_load_8");
+        symbol(&__atomic_load_16, "__atomic_load_16");
 
-        @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_store_16, .{ .name = "__atomic_store_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_store_1, "__atomic_store_1");
+        symbol(&__atomic_store_2, "__atomic_store_2");
+        symbol(&__atomic_store_4, "__atomic_store_4");
+        symbol(&__atomic_store_8, "__atomic_store_8");
+        symbol(&__atomic_store_16, "__atomic_store_16");
 
-        @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_exchange_16, .{ .name = "__atomic_exchange_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_exchange_1, "__atomic_exchange_1");
+        symbol(&__atomic_exchange_2, "__atomic_exchange_2");
+        symbol(&__atomic_exchange_4, "__atomic_exchange_4");
+        symbol(&__atomic_exchange_8, "__atomic_exchange_8");
+        symbol(&__atomic_exchange_16, "__atomic_exchange_16");
 
-        @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 });
-        @export(&__atomic_compare_exchange_16, .{ .name = "__atomic_compare_exchange_16", .linkage = linkage, .visibility = visibility });
+        symbol(&__atomic_compare_exchange_1, "__atomic_compare_exchange_1");
+        symbol(&__atomic_compare_exchange_2, "__atomic_compare_exchange_2");
+        symbol(&__atomic_compare_exchange_4, "__atomic_compare_exchange_4");
+        symbol(&__atomic_compare_exchange_8, "__atomic_compare_exchange_8");
+        symbol(&__atomic_compare_exchange_16, "__atomic_compare_exchange_16");
     }
 }
diff --git a/lib/compiler_rt/aulldiv.zig b/lib/compiler_rt/aulldiv.zig
index fbfa18dfd195c295c91514d21d9abce04ba9bea2..fb0d6126a86f46a3af3fca1b979be1245ce36b0f 100644
--- a/lib/compiler_rt/aulldiv.zig
+++ b/lib/compiler_rt/aulldiv.zig
@@ -1,15 +1,13 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
-const os = builtin.os.tag;
-const abi = builtin.abi;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_x86_msvc_abi) {
         // Don't let LLVM apply the stdcall name mangling on those MSVC builtins
-        @export(&_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_alldiv, "\x01__alldiv");
+        symbol(&_aulldiv, "\x01__aulldiv");
     }
 }
 
diff --git a/lib/compiler_rt/cmpdf2.zig b/lib/compiler_rt/cmpdf2.zig
index ebec596f270d739e689f3f735f94800a96ed95dc..691827ac4b2565a5e01a8c74ff7a0d785e788725 100644
--- a/lib/compiler_rt/cmpdf2.zig
+++ b/lib/compiler_rt/cmpdf2.zig
@@ -2,18 +2,19 @@
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @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 });
+        symbol(&__aeabi_dcmpeq, "__aeabi_dcmpeq");
+        symbol(&__aeabi_dcmplt, "__aeabi_dcmplt");
+        symbol(&__aeabi_dcmple, "__aeabi_dcmple");
     } else {
-        @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 });
+        symbol(&__eqdf2, "__eqdf2");
+        symbol(&__nedf2, "__nedf2");
+        symbol(&__ledf2, "__ledf2");
+        symbol(&__cmpdf2, "__cmpdf2");
+        symbol(&__ltdf2, "__ltdf2");
     }
 }
 
diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig
index 3188ecf90ec5f180fc500f39530a432354135673..846e62935c763e1311d0e635f6af6116d7eeea38 100644
--- a/lib/compiler_rt/cmptf2.zig
+++ b/lib/compiler_rt/cmptf2.zig
@@ -2,27 +2,28 @@
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @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 });
+        symbol(&__eqtf2, "__eqkf2");
+        symbol(&__netf2, "__nekf2");
+        symbol(&__lttf2, "__ltkf2");
+        symbol(&__letf2, "__lekf2");
     } else if (common.want_sparc_abi) {
-        @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 });
+        symbol(&_Qp_cmp, "_Qp_cmp");
+        symbol(&_Qp_feq, "_Qp_feq");
+        symbol(&_Qp_fne, "_Qp_fne");
+        symbol(&_Qp_flt, "_Qp_flt");
+        symbol(&_Qp_fle, "_Qp_fle");
+        symbol(&_Qp_fgt, "_Qp_fgt");
+        symbol(&_Qp_fge, "_Qp_fge");
     }
-    @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 });
+    symbol(&__eqtf2, "__eqtf2");
+    symbol(&__netf2, "__netf2");
+    symbol(&__letf2, "__letf2");
+    symbol(&__cmptf2, "__cmptf2");
+    symbol(&__lttf2, "__lttf2");
 }
 
 /// "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 a9b4c2296c5974415af57e3d2dc1aba2941f96cf..0839d78b1b34d4c18f87d9143c0d9599135899f9 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -3,23 +3,11 @@ const builtin = @import("builtin");
 const native_endian = builtin.cpu.arch.endian();
 const ofmt_c = builtin.object_format == .c;
 
-/// For now, we prefer weak linkage because some of the routines we implement here may also be
-/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
-/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883
-pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
-    .internal
-else if (ofmt_c)
-    .strong
-else
-    .weak;
+/// Deprecated, everything in common should move to compiler_rt.zig
+pub const linkage = @import("../compiler_rt.zig").linkage;
 
-/// 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 (linkage == .internal or builtin.link_mode == .dynamic)
-    .default
-else
-    .hidden;
+/// Deprecated, everything in common should move to compiler_rt.zig
+pub const visibility = @import("../compiler_rt.zig").visibility;
 
 pub const PreferredLoadStoreElement = element: {
     if (std.simd.suggestVectorLength(u8)) |vec_size| {
@@ -121,10 +109,8 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) {
 
 pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
 
-pub const test_safety = switch (builtin.zig_backend) {
-    .stage2_aarch64 => false,
-    else => builtin.is_test,
-};
+/// Deprecated, everything in common should move to compiler_rt.zig
+pub const test_safety = @import("../compiler_rt.zig").test_safety;
 
 /// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
 pub fn F16T(comptime OtherType: type) type {
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index 3384887385f0faeb4ad3c1b0b5f35e7a189ceb31..406098d56b9a172ca99f725b401cd42a27185047 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -2,22 +2,23 @@ const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+
 const common = @import("common.zig");
-
+const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 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, .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 });
+    symbol(&__cosh, "__cosh");
+    symbol(&cosf, "cosf");
+    symbol(&cos, "cos");
+    symbol(&__cosx, "__cosx");
     if (common.want_ppc_abi) {
-        @export(&cosq, .{ .name = "cosf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&cosq, "cosf128");
     }
-    @export(&cosq, .{ .name = "cosq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&cosl, .{ .name = "cosl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&cosq, "cosq");
+    symbol(&cosl, "cosl");
 }
 
 pub fn __cosh(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/count0bits.zig b/lib/compiler_rt/count0bits.zig
index 3696c899447e5328f1b13b369a0f9e41f1924ebe..12084864646b6d9e58c5c6147ce2b582dd7d4f9b 100644
--- a/lib/compiler_rt/count0bits.zig
+++ b/lib/compiler_rt/count0bits.zig
@@ -1,17 +1,17 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const std = @import("std");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__clzsi2, "__clzsi2");
+    symbol(&__clzdi2, "__clzdi2");
+    symbol(&__clzti2, "__clzti2");
+    symbol(&__ctzsi2, "__ctzsi2");
+    symbol(&__ctzdi2, "__ctzdi2");
+    symbol(&__ctzti2, "__ctzti2");
+    symbol(&__ffssi2, "__ffssi2");
+    symbol(&__ffsdi2, "__ffsdi2");
+    symbol(&__ffsti2, "__ffsti2");
 }
 
 // clz - count leading zeroes
diff --git a/lib/compiler_rt/divdc3.zig b/lib/compiler_rt/divdc3.zig
index ce2797ee39a1b03cd6d602e27c9c431f92978457..e26dd26d61552832bcd1d19c022e8b0455551a40 100644
--- a/lib/compiler_rt/divdc3.zig
+++ b/lib/compiler_rt/divdc3.zig
@@ -1,10 +1,10 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__divdc3, .{ .name = "__divdc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divdc3, "__divdc3");
     }
 }
 
diff --git a/lib/compiler_rt/divdf3.zig b/lib/compiler_rt/divdf3.zig
index a94544165bdfc11531e877a7c919e6085e60fb39..c57b432832da60e2eefe2d3ca6e75f499fa2b301 100644
--- a/lib/compiler_rt/divdf3.zig
+++ b/lib/compiler_rt/divdf3.zig
@@ -3,18 +3,17 @@
 //! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divdf3.c
 
 const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 const normalize = common.normalize;
 const wideMultiply = common.wideMultiply;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_ddiv, "__aeabi_ddiv");
     } else {
-        @export(&__divdf3, .{ .name = "__divdf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divdf3, "__divdf3");
     }
 }
 
diff --git a/lib/compiler_rt/divhf3.zig b/lib/compiler_rt/divhf3.zig
index 84bfe378710325a7d5994f92623c35603a11ed2d..fc2710ff2761fce7e8822583b86aefc562f98486 100644
--- a/lib/compiler_rt/divhf3.zig
+++ b/lib/compiler_rt/divhf3.zig
@@ -1,8 +1,8 @@
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const divsf3 = @import("./divsf3.zig");
 
 comptime {
-    @export(&__divhf3, .{ .name = "__divhf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divhf3, "__divhf3");
 }
 
 pub fn __divhf3(a: f16, b: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/divmodei4.zig b/lib/compiler_rt/divmodei4.zig
index ab11452206f5d52d3a709b5c90fb23344a59cf72..d96be7dec5cd71011da2b7744a22e1203335e540 100644
--- a/lib/compiler_rt/divmodei4.zig
+++ b/lib/compiler_rt/divmodei4.zig
@@ -1,15 +1,17 @@
-const std = @import("std");
 const builtin = @import("builtin");
+const endian = builtin.cpu.arch.endian();
+
+const std = @import("std");
+
 const common = @import("common.zig");
 const udivmod = @import("udivmodei4.zig").divmod;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__divei4, .{ .name = "__divei4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divei4, "__divei4");
+    symbol(&__modei4, "__modei4");
 }
 
-const endian = builtin.cpu.arch.endian();
-
 inline fn limb(x: []u32, i: usize) *u32 {
     return if (endian == .little) &x[i] else &x[x.len - 1 - i];
 }
diff --git a/lib/compiler_rt/divsc3.zig b/lib/compiler_rt/divsc3.zig
index 504d8f7d67ace593a310e15d6594ccdb1aba0ad7..9378bfab8ce80584b3b5b1b6d1fbd70200ef6648 100644
--- a/lib/compiler_rt/divsc3.zig
+++ b/lib/compiler_rt/divsc3.zig
@@ -1,10 +1,10 @@
-const common = @import("./common.zig");
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__divsc3, .{ .name = "__divsc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divsc3, "__divsc3");
     }
 }
 
diff --git a/lib/compiler_rt/divsf3.zig b/lib/compiler_rt/divsf3.zig
index dca1d49ebe0cdd0f8e1c66fd758ba8f91ea10a09..67e24de80dde507f71b290ea9884658b739cd503 100644
--- a/lib/compiler_rt/divsf3.zig
+++ b/lib/compiler_rt/divsf3.zig
@@ -3,17 +3,16 @@
 //! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divsf3.c
 
 const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
 
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const normalize = common.normalize;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_fdiv, "__aeabi_fdiv");
     } else {
-        @export(&__divsf3, .{ .name = "__divsf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divsf3, "__divsf3");
     }
 }
 
diff --git a/lib/compiler_rt/divtc3.zig b/lib/compiler_rt/divtc3.zig
index 3bdf2a90338d9c5b65634e160e9a5342b48a7280..d686958621958a2fe81446d5cdab03001629650c 100644
--- a/lib/compiler_rt/divtc3.zig
+++ b/lib/compiler_rt/divtc3.zig
@@ -1,12 +1,13 @@
 const common = @import("./common.zig");
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
         if (common.want_ppc_abi)
-            @export(&__divtc3, .{ .name = "__divkc3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__divtc3, .{ .name = "__divtc3", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__divtc3, "__divkc3");
+        symbol(&__divtc3, "__divtc3");
     }
 }
 
diff --git a/lib/compiler_rt/divxc3.zig b/lib/compiler_rt/divxc3.zig
index 6e5f7905dd63654f2d9d42fd74230614154ae46a..86c737a83931c6c34f73303eeaba00536d8e1bd4 100644
--- a/lib/compiler_rt/divxc3.zig
+++ b/lib/compiler_rt/divxc3.zig
@@ -1,10 +1,10 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const divc3 = @import("./divc3.zig");
 const Complex = @import("./mulc3.zig").Complex;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__divxc3, .{ .name = "__divxc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divxc3, "__divxc3");
     }
 }
 
diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig
index f25bf57092cbfbe850ab20e02ff127eb3c1822c2..3f18188fa0905669a373df546dd3924cec4dbb36 100644
--- a/lib/compiler_rt/exp.zig
+++ b/lib/compiler_rt/exp.zig
@@ -4,25 +4,28 @@
 // https://git.musl-libc.org/cgit/musl/tree/src/math/expf.c
 // https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c
 
-const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
+
+const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__exph, "__exph");
+    symbol(&expf, "expf");
+    symbol(&exp, "exp");
+    symbol(&__expx, "__expx");
     if (common.want_ppc_abi) {
-        @export(&expq, .{ .name = "expf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&expq, "expf128");
     }
-    @export(&expq, .{ .name = "expq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&expl, .{ .name = "expl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&expq, "expq");
+    symbol(&expl, "expl");
 }
 
 pub fn __exph(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/extenddftf2.zig b/lib/compiler_rt/extenddftf2.zig
index 9ef552c2c55032bcca12bb99c7f3dbbf3f121e5e..0204de48edbf75097daa2a387b9618990260a3bb 100644
--- a/lib/compiler_rt/extenddftf2.zig
+++ b/lib/compiler_rt/extenddftf2.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const extendf = @import("./extendf.zig").extendf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__extenddftf2, .{ .name = "__extenddfkf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__extenddftf2, "__extenddfkf2");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_dtoq, "_Qp_dtoq");
     }
-    @export(&__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extenddftf2, "__extenddftf2");
 }
 
 pub fn __extenddftf2(a: f64) callconv(.c) f128 {
diff --git a/lib/compiler_rt/extendhfdf2.zig b/lib/compiler_rt/extendhfdf2.zig
index 3b3b65ec114ceb3e11d743fa664b794c3bc2b773..2191bafe136c94e75527a363626779f55302b334 100644
--- a/lib/compiler_rt/extendhfdf2.zig
+++ b/lib/compiler_rt/extendhfdf2.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const extendf = @import("./extendf.zig").extendf;
 
 comptime {
-    @export(&__extendhfdf2, .{ .name = "__extendhfdf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendhfdf2, "__extendhfdf2");
 }
 
 pub fn __extendhfdf2(a: common.F16T(f64)) callconv(.c) f64 {
diff --git a/lib/compiler_rt/extendhfsf2.zig b/lib/compiler_rt/extendhfsf2.zig
index f4f8be4305c846f3f5d9d748c9b7c2b383aa5768..2c734f0147651e165bafa14111289d22e776085c 100644
--- a/lib/compiler_rt/extendhfsf2.zig
+++ b/lib/compiler_rt/extendhfsf2.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const extendf = @import("./extendf.zig").extendf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.gnu_f16_abi) {
-        @export(&__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__gnu_h2f_ieee, "__gnu_h2f_ieee");
     } else if (common.want_aeabi) {
-        @export(&__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_h2f, "__aeabi_h2f");
     }
-    @export(&__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendhfsf2, "__extendhfsf2");
 }
 
 pub fn __extendhfsf2(a: common.F16T(f32)) callconv(.c) f32 {
diff --git a/lib/compiler_rt/extendsfxf2.zig b/lib/compiler_rt/extendsfxf2.zig
index 8665c445f770c60c7c9d2af732c8c46f0a9ddf50..9a6796bd668602b1d653a6581613fcb69edb7853 100644
--- a/lib/compiler_rt/extendsfxf2.zig
+++ b/lib/compiler_rt/extendsfxf2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const extend_f80 = @import("./extendf.zig").extend_f80;
 
 comptime {
-    @export(&__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendsfxf2, "__extendsfxf2");
 }
 
 fn __extendsfxf2(a: f32) callconv(.c) f80 {
diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig
index cec1fa1f7ce9891734177d7baab3776307bd4657..1c39e1e84c7a3beb0a9470a123c05dea456eed77 100644
--- a/lib/compiler_rt/extendxftf2.zig
+++ b/lib/compiler_rt/extendxftf2.zig
@@ -1,8 +1,9 @@
 const std = @import("std");
-const common = @import("./common.zig");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__extendxftf2, .{ .name = "__extendxftf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__extendxftf2, "__extendxftf2");
 }
 
 fn __extendxftf2(a: f80) callconv(.c) f128 {
diff --git a/lib/compiler_rt/fixdfsi.zig b/lib/compiler_rt/fixdfsi.zig
index b1b26867b9c1899c73efe201c43f04ee95da3a58..7707f898302898743dc5c07b0969967c40e2163e 100644
--- a/lib/compiler_rt/fixdfsi.zig
+++ b/lib/compiler_rt/fixdfsi.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_d2iz, "__aeabi_d2iz");
     } else {
-        @export(&__fixdfsi, .{ .name = "__fixdfsi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixdfsi, "__fixdfsi");
     }
 }
 
diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig
index 499811c5511a30c9724aca2fab257efe4b470465..64c5a080f91a2c9afc2e9bb265a599a207e3312a 100644
--- a/lib/compiler_rt/fixdfti.zig
+++ b/lib/compiler_rt/fixdfti.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixdfti_windows_x86_64, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixdfti_windows_x86_64, "__fixdfti");
     } else {
-        @export(&__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixdfti, "__fixdfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixsfdi.zig b/lib/compiler_rt/fixsfdi.zig
index 894d5a0c1353b6a1890decd86d4ba7d41f2366b8..b2880aefc23714d1ecfa6cf2456d2ab55b737d14 100644
--- a/lib/compiler_rt/fixsfdi.zig
+++ b/lib/compiler_rt/fixsfdi.zig
@@ -1,15 +1,16 @@
 const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_f2lz, "__aeabi_f2lz");
     } else {
         if (common.want_windows_arm_abi) {
-            @export(&__fixsfdi, .{ .name = "__stoi64", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__fixsfdi, "__stoi64");
         }
-        @export(&__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixsfdi, "__fixsfdi");
     }
 }
 
diff --git a/lib/compiler_rt/fixtfdi.zig b/lib/compiler_rt/fixtfdi.zig
index 5c41f56595e5bdcddb55fdc63caab5836f0a22f3..bc1c8e56eb4fa3d3a06dd991972c7f22df500917 100644
--- a/lib/compiler_rt/fixtfdi.zig
+++ b/lib/compiler_rt/fixtfdi.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__fixtfdi, .{ .name = "__fixkfdi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixtfdi, "__fixkfdi");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_qtox, "_Qp_qtox");
     }
-    @export(&__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixtfdi, "__fixtfdi");
 }
 
 pub fn __fixtfdi(a: f128) callconv(.c) i64 {
diff --git a/lib/compiler_rt/fixtfsi.zig b/lib/compiler_rt/fixtfsi.zig
index 0d525cf8c4c442175fa7ebf39af2711823f74243..0919566a804a68d3ebb050fea1c74a2294d1f598 100644
--- a/lib/compiler_rt/fixtfsi.zig
+++ b/lib/compiler_rt/fixtfsi.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__fixtfsi, .{ .name = "__fixkfsi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixtfsi, "__fixkfsi");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_qtoi, "_Qp_qtoi");
     }
-    @export(&__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixtfsi, "__fixtfsi");
 }
 
 pub fn __fixtfsi(a: f128) callconv(.c) i32 {
diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig
index fe71a0f08906d929771ff367b97921b6044a05b8..2a1a928256a380e4336aac7e8b5b9dad9390a7ea 100644
--- a/lib/compiler_rt/fixtfti.zig
+++ b/lib/compiler_rt/fixtfti.zig
@@ -1,14 +1,14 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixtfti_windows_x86_64, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixtfti_windows_x86_64, "__fixtfti");
     } else {
         if (common.want_ppc_abi)
-            @export(&__fixtfti, .{ .name = "__fixkfti", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__fixtfti, "__fixkfti");
+        symbol(&__fixtfti, "__fixtfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunsdfei.zig b/lib/compiler_rt/fixunsdfei.zig
index be5bbf0a8a7a4c51c72609fe76e93b76ff81012f..f564f7f7a32869e7cdad92a2f264941a3eab7511 100644
--- a/lib/compiler_rt/fixunsdfei.zig
+++ b/lib/compiler_rt/fixunsdfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunsdfei, .{ .name = "__fixunsdfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunsdfei, "__fixunsdfei");
 }
 
 pub fn __fixunsdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig
index 28b79a0733b0cb8a881b4c5556d7ce32690d1069..a90b3d67fb5e5fc5640447b74464c65b18705d9a 100644
--- a/lib/compiler_rt/fixunsdfti.zig
+++ b/lib/compiler_rt/fixunsdfti.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti");
     } else {
-        @export(&__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunsdfti, "__fixunsdfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunshfdi.zig b/lib/compiler_rt/fixunshfdi.zig
index a949ee99045d07e3a007c074bf974fcb95c28fb6..741e482506d2df3ffbb1388a9848f9317f6f1808 100644
--- a/lib/compiler_rt/fixunshfdi.zig
+++ b/lib/compiler_rt/fixunshfdi.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    @export(&__fixunshfdi, .{ .name = "__fixunshfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunshfdi, "__fixunshfdi");
 }
 
 fn __fixunshfdi(a: f16) callconv(.c) u64 {
diff --git a/lib/compiler_rt/fixunshfei.zig b/lib/compiler_rt/fixunshfei.zig
index 4cb7ef2ba8da0c8d9862cd3ea0e9425429834fba..a61d94f3958f4cc8f5f01f57f317e5a44f32fc20 100644
--- a/lib/compiler_rt/fixunshfei.zig
+++ b/lib/compiler_rt/fixunshfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunshfei, .{ .name = "__fixunshfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunshfei, "__fixunshfei");
 }
 
 pub fn __fixunshfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig
index c61be597e772b6abebe139712a00c0f251747c6b..454aa9d57569749bf2d304baf6e3bac85bdd867a 100644
--- a/lib/compiler_rt/fixunshfti.zig
+++ b/lib/compiler_rt/fixunshfti.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixunshfti_windows_x86_64, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunshfti_windows_x86_64, "__fixunshfti");
     } else {
-        @export(&__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunshfti, "__fixunshfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunssfei.zig b/lib/compiler_rt/fixunssfei.zig
index 0fb957ed1f79ed31b5f27f5f1b368fec7b4655a6..2fd123bd1b4693f96b51604a794dc2879660dc87 100644
--- a/lib/compiler_rt/fixunssfei.zig
+++ b/lib/compiler_rt/fixunssfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunssfei, .{ .name = "__fixunssfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunssfei, "__fixunssfei");
 }
 
 pub fn __fixunssfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig
index 693442417c77cab0c74bff9135025ab86bcde86f..73e2d2a3f6b81926d346f9c04da8f880e4acf616 100644
--- a/lib/compiler_rt/fixunssfti.zig
+++ b/lib/compiler_rt/fixunssfti.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixunssfti_windows_x86_64, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunssfti_windows_x86_64, "__fixunssfti");
     } else {
-        @export(&__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixunssfti, "__fixunssfti");
     }
 }
 
diff --git a/lib/compiler_rt/fixunstfei.zig b/lib/compiler_rt/fixunstfei.zig
index 84ac5010c96e9c3113eec67e9ca6f5291787f9e8..3d8986da90790a1a9cbf9a5fa2939e94c8009cc2 100644
--- a/lib/compiler_rt/fixunstfei.zig
+++ b/lib/compiler_rt/fixunstfei.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunstfei, .{ .name = "__fixunstfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunstfei, "__fixunstfei");
 }
 
 pub fn __fixunstfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void {
diff --git a/lib/compiler_rt/fixunsxfdi.zig b/lib/compiler_rt/fixunsxfdi.zig
index 4dffd0253ee533db22eba53b5c5e6334cf0bf593..8385961b6b2ea2cd7632776ffa46d41e9e6f8bf3 100644
--- a/lib/compiler_rt/fixunsxfdi.zig
+++ b/lib/compiler_rt/fixunsxfdi.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunsxfdi, "__fixunsxfdi");
 }
 
 fn __fixunsxfdi(a: f80) callconv(.c) u64 {
diff --git a/lib/compiler_rt/fixunsxfei.zig b/lib/compiler_rt/fixunsxfei.zig
index dc795e74c691e6cb6c0927ef703163aa5481f5b6..d7902ddff54773d5240a57c8aaf6910ab6f9f02e 100644
--- a/lib/compiler_rt/fixunsxfei.zig
+++ b/lib/compiler_rt/fixunsxfei.zig
@@ -1,10 +1,10 @@
 const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
 
 comptime {
-    @export(&__fixunsxfei, .{ .name = "__fixunsxfei", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixunsxfei, "__fixunsxfei");
 }
 
 pub fn __fixunsxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void {
diff --git a/lib/compiler_rt/fixxfdi.zig b/lib/compiler_rt/fixxfdi.zig
index 155fead1bbe18c813a7a641700c23f3e6e41c431..e9e4b7528b07168dafdf4791a6cc13d795d5b78a 100644
--- a/lib/compiler_rt/fixxfdi.zig
+++ b/lib/compiler_rt/fixxfdi.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
 
 comptime {
-    @export(&__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__fixxfdi, "__fixxfdi");
 }
 
 fn __fixxfdi(a: f80) callconv(.c) i64 {
diff --git a/lib/compiler_rt/fixxfti.zig b/lib/compiler_rt/fixxfti.zig
index 292b9688e7fa1b627edf9943915dba087141bdc7..2f43814eacf1dd310a878f0e42e546250ea5f424 100644
--- a/lib/compiler_rt/fixxfti.zig
+++ b/lib/compiler_rt/fixxfti.zig
@@ -1,12 +1,14 @@
 const builtin = @import("builtin");
+
 const common = @import("./common.zig");
 const intFromFloat = @import("./int_from_float.zig").intFromFloat;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__fixxfti_windows_x86_64, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixxfti_windows_x86_64, "__fixxfti");
     } else {
-        @export(&__fixxfti, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixxfti, "__fixxfti");
     }
 }
 
diff --git a/lib/compiler_rt/floatdihf.zig b/lib/compiler_rt/floatdihf.zig
index fd534e5946202527e9b6ce1cef31e970230c384b..c6865dff6b8025e49b8f1a0ffc36674c230247a4 100644
--- a/lib/compiler_rt/floatdihf.zig
+++ b/lib/compiler_rt/floatdihf.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatdihf, .{ .name = "__floatdihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatdihf, "__floatdihf");
 }
 
 fn __floatdihf(a: i64) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floatdisf.zig b/lib/compiler_rt/floatdisf.zig
index 1efd9c937ff2b2849db3be096696bff395d55f0a..691ba91f26b9228380481258dca2f0719e67b09d 100644
--- a/lib/compiler_rt/floatdisf.zig
+++ b/lib/compiler_rt/floatdisf.zig
@@ -1,15 +1,15 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_l2f, "__aeabi_l2f");
     } else {
         if (common.want_windows_arm_abi) {
-            @export(&__floatdisf, .{ .name = "__i64tos", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floatdisf, "__i64tos");
         }
-        @export(&__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatdisf, "__floatdisf");
     }
 }
 
diff --git a/lib/compiler_rt/floatditf.zig b/lib/compiler_rt/floatditf.zig
index 864361b7b3d567f959e1e6cde55e20b40a9d487c..03182aab0b96e04619ecc48fff90f80548bb2c29 100644
--- a/lib/compiler_rt/floatditf.zig
+++ b/lib/compiler_rt/floatditf.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__floatditf, .{ .name = "__floatdikf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatditf, "__floatdikf");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_xtoq, "_Qp_xtoq");
     }
-    @export(&__floatditf, .{ .name = "__floatditf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatditf, "__floatditf");
 }
 
 pub fn __floatditf(a: i64) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatdixf.zig b/lib/compiler_rt/floatdixf.zig
index 8ac6f06fb5929319ad28e387377b120ae3e95e37..6bd06245d584402e7ed93b0d57d71f471bde05d4 100644
--- a/lib/compiler_rt/floatdixf.zig
+++ b/lib/compiler_rt/floatdixf.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatdixf, .{ .name = "__floatdixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatdixf, "__floatdixf");
 }
 
 fn __floatdixf(a: i64) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floateidf.zig b/lib/compiler_rt/floateidf.zig
index 6434743939ec3895302925bca84937d42d6a2287..ac3972c28778600d342d0412741e9a3e41797546 100644
--- a/lib/compiler_rt/floateidf.zig
+++ b/lib/compiler_rt/floateidf.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__floateidf, .{ .name = "__floateidf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floateidf, "__floateidf");
 }
 
 pub fn __floateidf(a: [*]const u8, bits: usize) callconv(.c) f64 {
diff --git a/lib/compiler_rt/floateixf.zig b/lib/compiler_rt/floateixf.zig
index ffb8445fd337ae8d7311233675435f7e7a3af1f7..dafefa4e8f11b978f26b5e4d10cc8b0feeed480b 100644
--- a/lib/compiler_rt/floateixf.zig
+++ b/lib/compiler_rt/floateixf.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floateixf, .{ .name = "__floateixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floateixf, "__floateixf");
 }
 
 pub fn __floateixf(a: [*]const u8, bits: usize) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floatsixf.zig b/lib/compiler_rt/floatsixf.zig
index 59bf7ddb99ffd827ab0fe52540ecf7af99a80477..0d5fcb340db962c8fa7231eed32f5076c9486b7a 100644
--- a/lib/compiler_rt/floatsixf.zig
+++ b/lib/compiler_rt/floatsixf.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__floatsixf, .{ .name = "__floatsixf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatsixf, "__floatsixf");
 }
 
 fn __floatsixf(a: i32) callconv(.c) f80 {
diff --git a/lib/compiler_rt/floattidf.zig b/lib/compiler_rt/floattidf.zig
index 2ac5726b5166ab233125ae44dcf74a4fe11eed5b..db48fe8af37195b59db7ce5f16790a88b4f09f2e 100644
--- a/lib/compiler_rt/floattidf.zig
+++ b/lib/compiler_rt/floattidf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floattidf_windows_x86_64, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattidf_windows_x86_64, "__floattidf");
     } else {
-        @export(&__floattidf, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattidf, "__floattidf");
     }
 }
 
diff --git a/lib/compiler_rt/floattisf.zig b/lib/compiler_rt/floattisf.zig
index 953192f33115a103b27f48a56875ab7176c2af15..3e5fffcfd8fec0d5972819955b703bffa45f3fb1 100644
--- a/lib/compiler_rt/floattisf.zig
+++ b/lib/compiler_rt/floattisf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floattisf_windows_x86_64, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattisf_windows_x86_64, "__floattisf");
     } else {
-        @export(&__floattisf, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattisf, "__floattisf");
     }
 }
 
diff --git a/lib/compiler_rt/floattitf.zig b/lib/compiler_rt/floattitf.zig
index 3973aa4ab294fea0b9f905194bebc914a9532cd5..e8e301c42d36f9faa01e6f13d4cb77eb6a19739a 100644
--- a/lib/compiler_rt/floattitf.zig
+++ b/lib/compiler_rt/floattitf.zig
@@ -1,14 +1,14 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floattitf_windows_x86_64, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattitf_windows_x86_64, "__floattitf");
     } else {
         if (common.want_ppc_abi)
-            @export(&__floattitf, .{ .name = "__floattikf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__floattitf, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floattitf, "__floattikf");
+        symbol(&__floattitf, "__floattitf");
     }
 }
 
diff --git a/lib/compiler_rt/floatundidf.zig b/lib/compiler_rt/floatundidf.zig
index 7a9e4afe7af40701c85b9347ddedf36ead437f17..6530f76ee70ed4070392e299274cb84bcf6e90e3 100644
--- a/lib/compiler_rt/floatundidf.zig
+++ b/lib/compiler_rt/floatundidf.zig
@@ -1,15 +1,15 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_ul2d, "__aeabi_ul2d");
     } else {
         if (common.want_windows_arm_abi) {
-            @export(&__floatundidf, .{ .name = "__u64tod", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floatundidf, "__u64tod");
         }
-        @export(&__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatundidf, "__floatundidf");
     }
 }
 
diff --git a/lib/compiler_rt/floatuneitf.zig b/lib/compiler_rt/floatuneitf.zig
index d84678ce115f88c3cb21cc5203fb162f6404a653..ddee65dfb18b793bffe08d850384842fcff5747e 100644
--- a/lib/compiler_rt/floatuneitf.zig
+++ b/lib/compiler_rt/floatuneitf.zig
@@ -1,10 +1,12 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+
+const std = @import("std");
+
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
 
 comptime {
-    @export(&__floatuneitf, .{ .name = "__floatuneitf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatuneitf, "__floatuneitf");
 }
 
 pub fn __floatuneitf(a: [*]const u8, bits: usize) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatunsihf.zig b/lib/compiler_rt/floatunsihf.zig
index 123b76fcde1b1175e74902f26e2ff820a2d6c662..a2e42ca10f3af950e900f5250fa6a3d23e2b1266 100644
--- a/lib/compiler_rt/floatunsihf.zig
+++ b/lib/compiler_rt/floatunsihf.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
-    @export(&__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatunsihf, "__floatunsihf");
 }
 
 pub fn __floatunsihf(a: u32) callconv(.c) f16 {
diff --git a/lib/compiler_rt/floatunsisf.zig b/lib/compiler_rt/floatunsisf.zig
index 4bcceba5c8c967a73312765468a98876a5b128c9..72ac1a59017743f319dd65b8d609d499999715fd 100644
--- a/lib/compiler_rt/floatunsisf.zig
+++ b/lib/compiler_rt/floatunsisf.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_ui2f, "__aeabi_ui2f");
     } else {
-        @export(&__floatunsisf, .{ .name = "__floatunsisf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatunsisf, "__floatunsisf");
     }
 }
 
diff --git a/lib/compiler_rt/floatunsitf.zig b/lib/compiler_rt/floatunsitf.zig
index e491987003f054005b841a316f414412dfb9ecb8..6ad2ca5c5638834b27490bc3bbde0ec3a743ad77 100644
--- a/lib/compiler_rt/floatunsitf.zig
+++ b/lib/compiler_rt/floatunsitf.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__floatunsitf, .{ .name = "__floatunsikf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatunsitf, "__floatunsikf");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_uitoq, "_Qp_uitoq");
     }
-    @export(&__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__floatunsitf, "__floatunsitf");
 }
 
 pub fn __floatunsitf(a: u32) callconv(.c) f128 {
diff --git a/lib/compiler_rt/floatuntidf.zig b/lib/compiler_rt/floatuntidf.zig
index 284e50dd367bd6dfed766842fffa0f8fecd43815..d2d34f57545fd787b35e772deacd1cae19ba9af5 100644
--- a/lib/compiler_rt/floatuntidf.zig
+++ b/lib/compiler_rt/floatuntidf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntidf_windows_x86_64, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntidf_windows_x86_64, "__floatuntidf");
     } else {
-        @export(&__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntidf, "__floatuntidf");
     }
 }
 
diff --git a/lib/compiler_rt/floatuntihf.zig b/lib/compiler_rt/floatuntihf.zig
index 41da6f1bfb501f9b78ab65277cb4a49da40f6ad6..629e8088eb5abacfba51edd1915045833892cdb4 100644
--- a/lib/compiler_rt/floatuntihf.zig
+++ b/lib/compiler_rt/floatuntihf.zig
@@ -1,12 +1,12 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntihf_windows_x86_64, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntihf_windows_x86_64, "__floatuntihf");
     } else {
-        @export(&__floatuntihf, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntihf, "__floatuntihf");
     }
 }
 
diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig
index 77dd22ed5978b6b86019d4c50ed7421003f7041a..64063495b8dc0f423ab06d6ce359ca1f772665c6 100644
--- a/lib/compiler_rt/floatuntitf.zig
+++ b/lib/compiler_rt/floatuntitf.zig
@@ -1,14 +1,14 @@
-const builtin = @import("builtin");
 const common = @import("./common.zig");
 const floatFromInt = @import("./float_from_int.zig").floatFromInt;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_windows_v2u64_abi) {
-        @export(&__floatuntitf_windows_x86_64, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntitf_windows_x86_64, "__floatuntitf");
     } else {
         if (common.want_ppc_abi)
-            @export(&__floatuntitf, .{ .name = "__floatuntikf", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__floatuntitf, "__floatuntikf");
+        symbol(&__floatuntitf, "__floatuntitf");
     }
 }
 
diff --git a/lib/compiler_rt/floor_ceil.zig b/lib/compiler_rt/floor_ceil.zig
index e669cb812d7268a12fd1c9db48b52e840f3863c1..c44e9c2e571eee6c009a13ed10c98742a5ec8940 100644
--- a/lib/compiler_rt/floor_ceil.zig
+++ b/lib/compiler_rt/floor_ceil.zig
@@ -15,29 +15,30 @@ const mem = std.mem;
 const expect = std.testing.expect;
 
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     // floor
-    @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 });
+    symbol(&__floorh, "__floorh");
+    symbol(&floorf, "floorf");
+    symbol(&floor, "floor");
+    symbol(&__floorx, "__floorx");
     if (common.want_ppc_abi) {
-        @export(&floorq, .{ .name = "floorf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&floorq, "floorf128");
     }
-    @export(&floorq, .{ .name = "floorq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&floorl, .{ .name = "floorl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&floorq, "floorq");
+    symbol(&floorl, "floorl");
 
     // ceil
-    @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 });
+    symbol(&__ceilh, "__ceilh");
+    symbol(&ceilf, "ceilf");
+    symbol(&ceil, "ceil");
+    symbol(&__ceilx, "__ceilx");
     if (common.want_ppc_abi) {
-        @export(&ceilq, .{ .name = "ceilf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&ceilq, "ceilf128");
     }
-    @export(&ceilq, .{ .name = "ceilq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&ceill, .{ .name = "ceill", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&ceilq, "ceilq");
+    symbol(&ceill, "ceill");
 }
 
 pub fn __floorh(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/gedf2.zig b/lib/compiler_rt/gedf2.zig
index aeb08b4a8b9eae9979b99ba37db0db4047992a92..bd16de17f82329b39e158265f5616ebbdd12b510 100644
--- a/lib/compiler_rt/gedf2.zig
+++ b/lib/compiler_rt/gedf2.zig
@@ -2,14 +2,15 @@
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dcmpge, "__aeabi_dcmpge");
+        symbol(&__aeabi_dcmpgt, "__aeabi_dcmpgt");
     } else {
-        @export(&__gedf2, .{ .name = "__gedf2", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__gedf2, "__gedf2");
+        symbol(&__gtdf2, "__gtdf2");
     }
 }
 
diff --git a/lib/compiler_rt/gehf2.zig b/lib/compiler_rt/gehf2.zig
index b46d4a1a24d0038abc38ce6e6ca5d5dda8324ef8..e4e15a449d41b5e703498b9a1e66c6c6c1683d0d 100644
--- a/lib/compiler_rt/gehf2.zig
+++ b/lib/compiler_rt/gehf2.zig
@@ -1,11 +1,11 @@
 ///! The quoted behavior definitions are from
 ///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const comparef = @import("./comparef.zig");
 
 comptime {
-    @export(&__gehf2, .{ .name = "__gehf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__gthf2, .{ .name = "__gthf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__gehf2, "__gehf2");
+    symbol(&__gthf2, "__gthf2");
 }
 
 /// "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 365c298cc6161fd39f5360fedbbc0d70e6fa7c11..c6b3a1befdab554692b4d41411b933eefa227d4a 100644
--- a/lib/compiler_rt/gexf2.zig
+++ b/lib/compiler_rt/gexf2.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const comparef = @import("./comparef.zig");
 
 comptime {
-    @export(&__gexf2, .{ .name = "__gexf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__gexf2, "__gexf2");
+    symbol(&__gtxf2, "__gtxf2");
 }
 
 fn __gexf2(a: f80, b: f80) callconv(.c) i32 {
diff --git a/lib/compiler_rt/int.zig b/lib/compiler_rt/int.zig
index 3f38bad973d55ac78551fcda15deb1b2341e2c3c..01827cf6404d2e48826e14bb3c514e38519c9522 100644
--- a/lib/compiler_rt/int.zig
+++ b/lib/compiler_rt/int.zig
@@ -1,34 +1,37 @@
 //! Builtin functions that operate on integer types
 
 const builtin = @import("builtin");
+const arch = builtin.cpu.arch;
+
 const std = @import("std");
 const testing = std.testing;
 const maxInt = std.math.maxInt;
 const minInt = std.math.minInt;
-const arch = builtin.cpu.arch;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const udivmod = @import("udivmod.zig").udivmod;
 const __divti3 = @import("divti3.zig").__divti3;
 
 comptime {
-    @export(&__divmodti4, .{ .name = "__divmodti4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__divmoddi4, .{ .name = "__divmoddi4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__divmodti4, "__divmodti4");
+    symbol(&__udivmoddi4, "__udivmoddi4");
+    symbol(&__divmoddi4, "__divmoddi4");
     if (common.want_aeabi) {
-        @export(&__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_idiv, "__aeabi_idiv");
+        symbol(&__aeabi_uidiv, "__aeabi_uidiv");
     } else {
-        @export(&__divsi3, .{ .name = "__divsi3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__udivsi3, .{ .name = "__udivsi3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divsi3, "__divsi3");
+        symbol(&__udivsi3, "__udivsi3");
     }
-    @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 });
+    symbol(&__divdi3, "__divdi3");
+    symbol(&__udivdi3, "__udivdi3");
+    symbol(&__modsi3, "__modsi3");
+    symbol(&__moddi3, "__moddi3");
+    symbol(&__umodsi3, "__umodsi3");
+    symbol(&__umoddi3, "__umoddi3");
+    symbol(&__divmodsi4, "__divmodsi4");
+    symbol(&__udivmodsi4, "__udivmodsi4");
 }
 
 pub fn __divmodti4(a: i128, b: i128, rem: *i128) callconv(.c) i128 {
diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig
index 3270b27916169ace21dfa9a3f26f550d8fbd0c82..96dd319f720bf7237e603f82f7d2284866159af7 100644
--- a/lib/compiler_rt/log.zig
+++ b/lib/compiler_rt/log.zig
@@ -5,23 +5,23 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/log.c?h=1b76ff0767d01df72f692806ee5adee13c67ef88
 
 const std = @import("std");
-const builtin = @import("builtin");
 const math = std.math;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
-const arch = builtin.cpu.arch;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__logh, "__logh");
+    symbol(&logf, "logf");
+    symbol(&log, "log");
+    symbol(&__logx, "__logx");
     if (common.want_ppc_abi) {
-        @export(&logq, .{ .name = "logf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&logq, "logf128");
     }
-    @export(&logq, .{ .name = "logq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&logl, .{ .name = "logl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&logq, "logq");
+    symbol(&logl, "logl");
 }
 
 pub fn __logh(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig
index d501cef461a0d10fb78f441f30ffa4b2f023e5a9..d2741e3b231d8b0e6008f506b9cdef38e4bd392a 100644
--- a/lib/compiler_rt/log10.zig
+++ b/lib/compiler_rt/log10.zig
@@ -5,24 +5,24 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c
 
 const std = @import("std");
-const builtin = @import("builtin");
 const math = std.math;
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 const maxInt = std.math.maxInt;
-const arch = builtin.cpu.arch;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__log10h, "__log10h");
+    symbol(&log10f, "log10f");
+    symbol(&log10, "log10");
+    symbol(&__log10x, "__log10x");
     if (common.want_ppc_abi) {
-        @export(&log10q, .{ .name = "log10f128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&log10q, "log10f128");
     }
-    @export(&log10q, .{ .name = "log10q", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&log10l, .{ .name = "log10l", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&log10q, "log10q");
+    symbol(&log10l, "log10l");
 }
 
 pub fn __log10h(a: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/memcmp.zig b/lib/compiler_rt/memcmp.zig
deleted file mode 100644
index f332d82eac93d91e094c64a9b51181ba1417cb7e..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/memcmp.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-const std = @import("std");
-const common = @import("./common.zig");
-
-comptime {
-    @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 {
-    var i: usize = 0;
-    while (i < n) : (i += 1) {
-        const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]);
-        if (compared != 0) return compared;
-    }
-    return 0;
-}
-
-test "memcmp" {
-    const arr0 = &[_]u8{ 1, 1, 1 };
-    const arr1 = &[_]u8{ 1, 1, 1 };
-    const arr2 = &[_]u8{ 1, 0, 1 };
-    const arr3 = &[_]u8{ 1, 2, 1 };
-    const arr4 = &[_]u8{ 1, 0xff, 1 };
-
-    try std.testing.expect(memcmp(arr0, arr1, 3) == 0);
-    try std.testing.expect(memcmp(arr0, arr2, 3) > 0);
-    try std.testing.expect(memcmp(arr0, arr3, 3) < 0);
-
-    try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
-    try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
-}
diff --git a/lib/compiler_rt/muldc3.zig b/lib/compiler_rt/muldc3.zig
index 9670c1312887c99a038540ed097bb22daede93f3..d5facaa2b645670b6bf6e0953ec6b73342342329 100644
--- a/lib/compiler_rt/muldc3.zig
+++ b/lib/compiler_rt/muldc3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
 const mulc3 = @import("./mulc3.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__muldc3, .{ .name = "__muldc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__muldc3, "__muldc3");
     }
 }
 
diff --git a/lib/compiler_rt/muldf3.zig b/lib/compiler_rt/muldf3.zig
index cf67df0913ab624cb1f5a840f8da139e9d0d38a1..e9c978430ecd15dceba4896874e3c118374b1f04 100644
--- a/lib/compiler_rt/muldf3.zig
+++ b/lib/compiler_rt/muldf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const mulf3 = @import("./mulf3.zig").mulf3;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dmul, "__aeabi_dmul");
     } else {
-        @export(&__muldf3, .{ .name = "__muldf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__muldf3, "__muldf3");
     }
 }
 
diff --git a/lib/compiler_rt/mulsc3.zig b/lib/compiler_rt/mulsc3.zig
index 49c1e31aecd43e18961bf2c3853b8855993a917c..e735e65eade6a77f908abe8b4b25e8fc30af7f9f 100644
--- a/lib/compiler_rt/mulsc3.zig
+++ b/lib/compiler_rt/mulsc3.zig
@@ -1,9 +1,9 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const mulc3 = @import("./mulc3.zig");
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
-        @export(&__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__mulsc3, "__mulsc3");
     }
 }
 
diff --git a/lib/compiler_rt/multc3.zig b/lib/compiler_rt/multc3.zig
index 1ed373660f81ef101d6b37086b456a11dd546707..13870c6465e4d6e200119ab266ccd63f6769f306 100644
--- a/lib/compiler_rt/multc3.zig
+++ b/lib/compiler_rt/multc3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const mulc3 = @import("./mulc3.zig");
 
 comptime {
     if (@import("builtin").zig_backend != .stage2_c) {
         if (common.want_ppc_abi)
-            @export(&__multc3, .{ .name = "__mulkc3", .linkage = common.linkage, .visibility = common.visibility });
-        @export(&__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility });
+            symbol(&__multc3, "__mulkc3");
+        symbol(&__multc3, "__multc3");
     }
 }
 
diff --git a/lib/compiler_rt/mulvsi3.zig b/lib/compiler_rt/mulvsi3.zig
index e773ea0d9ad756fe0d8a834ed04f4c79834fa171..0935ea497afa52a46f515c83c40c2d8cc5bc02db 100644
--- a/lib/compiler_rt/mulvsi3.zig
+++ b/lib/compiler_rt/mulvsi3.zig
@@ -1,9 +1,10 @@
-const mulv = @import("mulo.zig");
-const common = @import("./common.zig");
 const testing = @import("std").testing;
 
+const mulv = @import("mulo.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
+
 comptime {
-    @export(&__mulvsi3, .{ .name = "__mulvsi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__mulvsi3, "__mulvsi3");
 }
 
 pub fn __mulvsi3(a: i32, b: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/negtf2.zig b/lib/compiler_rt/negtf2.zig
index ecb5cc2c9007256061a7f102029e1d14c75d0494..9d981ce2ffb3159d3377a1a9843a551cac5e8e2b 100644
--- a/lib/compiler_rt/negtf2.zig
+++ b/lib/compiler_rt/negtf2.zig
@@ -1,9 +1,10 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi)
-        @export(&__negtf2, .{ .name = "__negkf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__negtf2, .{ .name = "__negtf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__negtf2, "__negkf2");
+    symbol(&__negtf2, "__negtf2");
 }
 
 fn __negtf2(a: f128) callconv(.c) f128 {
diff --git a/lib/compiler_rt/parity.zig b/lib/compiler_rt/parity.zig
index 71d50f327b178d01545fb9315e01aee2061970cf..e3881699042fafc3fc0da7415e6fb2bb6d1aedde 100644
--- a/lib/compiler_rt/parity.zig
+++ b/lib/compiler_rt/parity.zig
@@ -1,14 +1,11 @@
 //! parity - if number of bits set is even => 0, else => 1
 //! - pariytXi2_generic for big and little endian
-
-const std = @import("std");
-const builtin = @import("builtin");
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__paritysi2, "__paritysi2");
+    symbol(&__paritydi2, "__paritydi2");
+    symbol(&__parityti2, "__parityti2");
 }
 
 pub fn __paritysi2(a: i32) callconv(.c) i32 {
@@ -24,7 +21,7 @@ pub fn __parityti2(a: i128) callconv(.c) i32 {
 }
 
 inline fn parityXi2(comptime T: type, a: T) i32 {
-    var x: std.meta.Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);
+    var x: @Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);
     // Bit Twiddling Hacks: Compute parity in parallel
     comptime var shift: u8 = @bitSizeOf(T) / 2;
     inline while (shift > 2) {
diff --git a/lib/compiler_rt/popcount.zig b/lib/compiler_rt/popcount.zig
index 12ecda16cc1c2c41119017ccf32c1405f9a434f8..b1ef500ea117514d08b598e4209770bd4b879b1f 100644
--- a/lib/compiler_rt/popcount.zig
+++ b/lib/compiler_rt/popcount.zig
@@ -6,14 +6,12 @@
 //! TAOCP: Combinational Algorithms, Bitwise Tricks And Techniques,
 //!   subsubsection "Working with the rightmost bits" and "Sideways addition".
 
-const builtin = @import("builtin");
-const std = @import("std");
-const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__popcountsi2, "__popcountsi2");
+    symbol(&__popcountdi2, "__popcountdi2");
+    symbol(&__popcountti2, "__popcountti2");
 }
 
 pub fn __popcountsi2(a: i32) callconv(.c) i32 {
diff --git a/lib/compiler_rt/powiXf2.zig b/lib/compiler_rt/powiXf2.zig
index b603998d556949d01c0915c51e2c50f72a509a82..91767818bd71cbe91d78a3454aaa31fe8d22ed68 100644
--- a/lib/compiler_rt/powiXf2.zig
+++ b/lib/compiler_rt/powiXf2.zig
@@ -3,18 +3,17 @@
 //! Multiplication order (left-to-right or right-to-left) does not matter for
 //! error propagation and this method is optimized for performance, not accuracy.
 
-const builtin = @import("builtin");
 const common = @import("common.zig");
-const std = @import("std");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__powihf2, .{ .name = "__powihf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powisf2, .{ .name = "__powisf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powidf2, .{ .name = "__powidf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__powihf2, "__powihf2");
+    symbol(&__powisf2, "__powisf2");
+    symbol(&__powidf2, "__powidf2");
     if (common.want_ppc_abi)
-        @export(&__powitf2, .{ .name = "__powikf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powitf2, .{ .name = "__powitf2", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__powixf2, .{ .name = "__powixf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__powitf2, "__powikf2");
+    symbol(&__powitf2, "__powitf2");
+    symbol(&__powixf2, "__powixf2");
 }
 
 inline fn powiXf2(comptime FT: type, a: FT, b: i32) FT {
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index d25c1cd23ae194c3dabed9c497714aca5457e95e..ab1775d7ce8f50c420085e0317675802108d7933 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -5,27 +5,26 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/sin.c
 
 const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+
 const common = @import("common.zig");
-
+const symbol = @import("../compiler_rt.zig").symbol;
 const trig = @import("trig.zig");
 const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
 const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 
 comptime {
-    @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 });
+    symbol(&__sinh, "__sinh");
+    symbol(&sinf, "sinf");
+    symbol(&sin, "sin");
+    symbol(&__sinx, "__sinx");
     if (common.want_ppc_abi) {
-        @export(&sinq, .{ .name = "sinf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&sinq, "sinf128");
     }
-    @export(&sinq, .{ .name = "sinq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&sinl, .{ .name = "sinl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&sinq, "sinq");
+    symbol(&sinl, "sinl");
 }
 
 pub fn __sinh(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/strlen.zig b/lib/compiler_rt/strlen.zig
deleted file mode 100644
index 01d4e760dc2c78f484937f9cf2b635d4452df0b6..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/strlen.zig
+++ /dev/null
@@ -1,10 +0,0 @@
-const std = @import("std");
-const common = @import("common.zig");
-
-comptime {
-    @export(&strlen, .{ .name = "strlen", .linkage = common.linkage, .visibility = common.visibility });
-}
-
-fn strlen(s: [*:0]const c_char) callconv(.c) usize {
-    return std.mem.len(s);
-}
diff --git a/lib/compiler_rt/subdf3.zig b/lib/compiler_rt/subdf3.zig
index b1d78509028c1a57217e188e23d28e70b04d6227..3e7dcc3dd27ae6fd78c3239fc4c6afe02f7f541a 100644
--- a/lib/compiler_rt/subdf3.zig
+++ b/lib/compiler_rt/subdf3.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const addf3 = @import("./addf3.zig").addf3;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dsub, "__aeabi_dsub");
     } else {
-        @export(&__subdf3, .{ .name = "__subdf3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__subdf3, "__subdf3");
     }
 }
 
diff --git a/lib/compiler_rt/subvdi3.zig b/lib/compiler_rt/subvdi3.zig
index 17c893c91141925285dd5eecbd6297523fbb57a2..62bb1b406835c1a72588cd9c1d08705f6663bbd2 100644
--- a/lib/compiler_rt/subvdi3.zig
+++ b/lib/compiler_rt/subvdi3.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const testing = @import("std").testing;
 
 comptime {
-    @export(&__subvdi3, .{ .name = "__subvdi3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__subvdi3, "__subvdi3");
 }
 
 pub fn __subvdi3(a: i64, b: i64) callconv(.c) i64 {
diff --git a/lib/compiler_rt/subxf3.zig b/lib/compiler_rt/subxf3.zig
index d119f0bd984fc311b2f67a89760c9f147397af9d..1c2dcd65429596c975937432aae6eaefb89c2f72 100644
--- a/lib/compiler_rt/subxf3.zig
+++ b/lib/compiler_rt/subxf3.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__subxf3, .{ .name = "__subxf3", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__subxf3, "__subxf3");
 }
 
 fn __subxf3(a: f80, b: f80) callconv(.c) f80 {
diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig
index a78d7afb67b491d1d5ebb246689dbc7e4b8d9f73..17b7f1f1e7c19b453a89c5594040d1fb27d6078e 100644
--- a/lib/compiler_rt/tan.zig
+++ b/lib/compiler_rt/tan.zig
@@ -17,17 +17,18 @@ const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
 
 const arch = builtin.cpu.arch;
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__tanh, "__tanh");
+    symbol(&tanf, "tanf");
+    symbol(&tan, "tan");
+    symbol(&__tanx, "__tanx");
     if (common.want_ppc_abi) {
-        @export(&tanq, .{ .name = "tanf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&tanq, "tanf128");
     }
-    @export(&tanq, .{ .name = "tanq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&tanl, .{ .name = "tanl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&tanq, "tanq");
+    symbol(&tanl, "tanl");
 }
 
 pub fn __tanh(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig
index 55468c752fa4ff279ab872f5bd15077576fe1186..799fbc9fbbdf4f3953987f401870371d1e4ea436 100644
--- a/lib/compiler_rt/trunc.zig
+++ b/lib/compiler_rt/trunc.zig
@@ -4,24 +4,27 @@
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/truncf.c
 //! https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c
 
-const std = @import("std");
 const builtin = @import("builtin");
 const arch = builtin.cpu.arch;
+
+const std = @import("std");
 const math = std.math;
 const mem = std.mem;
 const expect = std.testing.expect;
+
 const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @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 });
+    symbol(&__trunch, "__trunch");
+    symbol(&truncf, "truncf");
+    symbol(&trunc, "trunc");
+    symbol(&__truncx, "__truncx");
     if (common.want_ppc_abi) {
-        @export(&truncq, .{ .name = "truncf128", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&truncq, "truncf128");
     }
-    @export(&truncq, .{ .name = "truncq", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&truncl, .{ .name = "truncl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&truncq, "truncq");
+    symbol(&truncl, "truncl");
 }
 
 pub fn __trunch(x: f16) callconv(.c) f16 {
diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig
index 4db14f0211849bb30d47f429e24b7a510736aab6..43ad7fb20dd5a4b0afbab9846b44be3c94bce1c3 100644
--- a/lib/compiler_rt/truncdfhf2.zig
+++ b/lib/compiler_rt/truncdfhf2.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const truncf = @import("./truncf.zig").truncf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_d2h, "__aeabi_d2h");
     }
-    @export(&__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncdfhf2, "__truncdfhf2");
 }
 
 pub fn __truncdfhf2(a: f64) callconv(.c) common.F16T(f64) {
diff --git a/lib/compiler_rt/trunctfhf2.zig b/lib/compiler_rt/trunctfhf2.zig
index f5adc918c2d50fc455e08db16e09de88b25088a3..bd0e7a5dc24806071622438c95f02e8bbc6054a3 100644
--- a/lib/compiler_rt/trunctfhf2.zig
+++ b/lib/compiler_rt/trunctfhf2.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const truncf = @import("./truncf.zig").truncf;
 
 comptime {
-    @export(&__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__trunctfhf2, "__trunctfhf2");
 }
 
 pub fn __trunctfhf2(a: f128) callconv(.c) common.F16T(f128) {
diff --git a/lib/compiler_rt/trunctfsf2.zig b/lib/compiler_rt/trunctfsf2.zig
index 17e7570c9f0ecaa1b607d06deaf400a8ff83abc2..bab5534bfe08da10814e99e9015b41c02c0fe68e 100644
--- a/lib/compiler_rt/trunctfsf2.zig
+++ b/lib/compiler_rt/trunctfsf2.zig
@@ -1,13 +1,14 @@
 const common = @import("./common.zig");
 const truncf = @import("./truncf.zig").truncf;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(&__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__trunctfsf2, "__trunckfsf2");
     } else if (common.want_sparc_abi) {
-        @export(&_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&_Qp_qtos, "_Qp_qtos");
     }
-    @export(&__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__trunctfsf2, "__trunctfsf2");
 }
 
 pub fn __trunctfsf2(a: f128) callconv(.c) f32 {
diff --git a/lib/compiler_rt/truncxfdf2.zig b/lib/compiler_rt/truncxfdf2.zig
index 1d7e66c278f3c0ecf55fa3e034ed429ad5bae913..6140d94181fbe10a5e83e880dff805e87b34fae8 100644
--- a/lib/compiler_rt/truncxfdf2.zig
+++ b/lib/compiler_rt/truncxfdf2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
 
 comptime {
-    @export(&__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncxfdf2, "__truncxfdf2");
 }
 
 fn __truncxfdf2(a: f80) callconv(.c) f64 {
diff --git a/lib/compiler_rt/truncxfhf2.zig b/lib/compiler_rt/truncxfhf2.zig
index b2dd9c7468265eb8ac5c0b9d865327e4e2208493..b6abce58d5eb505e0547e5eebd3f111909565631 100644
--- a/lib/compiler_rt/truncxfhf2.zig
+++ b/lib/compiler_rt/truncxfhf2.zig
@@ -1,8 +1,9 @@
 const common = @import("./common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
 
 comptime {
-    @export(&__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncxfhf2, "__truncxfhf2");
 }
 
 fn __truncxfhf2(a: f80) callconv(.c) common.F16T(f80) {
diff --git a/lib/compiler_rt/truncxfsf2.zig b/lib/compiler_rt/truncxfsf2.zig
index 9d36f7aa29a407b0e266b74437cfdd0c869eae35..8aaf7e6906a9da938835d2c36e931bfb21d07037 100644
--- a/lib/compiler_rt/truncxfsf2.zig
+++ b/lib/compiler_rt/truncxfsf2.zig
@@ -1,8 +1,8 @@
-const common = @import("./common.zig");
 const trunc_f80 = @import("./truncf.zig").trunc_f80;
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
-    @export(&__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__truncxfsf2, "__truncxfsf2");
 }
 
 fn __truncxfsf2(a: f80) callconv(.c) f32 {
diff --git a/lib/compiler_rt/udivmodei4.zig b/lib/compiler_rt/udivmodei4.zig
index 0923f3f222fcdc070334afc3fdad4a610ecb4f6f..fd8cc6717e68b649d16f8a71ec36f7f576f326fa 100644
--- a/lib/compiler_rt/udivmodei4.zig
+++ b/lib/compiler_rt/udivmodei4.zig
@@ -1,18 +1,20 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const common = @import("common.zig");
+const endian = builtin.cpu.arch.endian();
+
+const std = @import("std");
 const shr = std.math.shr;
 const shl = std.math.shl;
 
+const common = @import("common.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
+
 const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max supported type is u65535
 
 comptime {
-    @export(&__udivei4, .{ .name = "__udivei4", .linkage = common.linkage, .visibility = common.visibility });
-    @export(&__umodei4, .{ .name = "__umodei4", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__udivei4, "__udivei4");
+    symbol(&__umodei4, "__umodei4");
 }
 
-const endian = builtin.cpu.arch.endian();
-
 /// Get the value of a limb.
 inline fn limb(x: []const u32, i: usize) u32 {
     return if (endian == .little) x[i] else x[x.len - 1 - i];
diff --git a/lib/compiler_rt/unorddf2.zig b/lib/compiler_rt/unorddf2.zig
index 5b17343a5168961aa57f61ee3ac3c9279ecd270e..634f14398df9661beaab7cdfe061008d4828bb6a 100644
--- a/lib/compiler_rt/unorddf2.zig
+++ b/lib/compiler_rt/unorddf2.zig
@@ -1,11 +1,12 @@
 const common = @import("./common.zig");
 const comparef = @import("./comparef.zig");
+const symbol = @import("../compiler_rt.zig").symbol;
 
 comptime {
     if (common.want_aeabi) {
-        @export(&__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dcmpun, "__aeabi_dcmpun");
     } else {
-        @export(&__unorddf2, .{ .name = "__unorddf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__unorddf2, "__unorddf2");
     }
 }