Commit 04c180c8e57fecdf3478de966f32b8a1f65ad202 | zig

lib/compiler_rt.zig+62-7

...	@@ -1,10 +1,11 @@	...	@@ -1,10 +1,11 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("compiler_rt/common.zig");	2	const ofmt_c = builtin.object_format == .c;
		3
		4	const std = @import("std");
4		5
5	/// Avoid dragging in the runtime safety mechanisms into this .o file, unless	6	/// Avoid dragging in the runtime safety mechanisms into this .o file, unless
6	/// we're trying to test compiler-rt.	7	/// we're trying to test compiler-rt.
7	pub const panic = if (common.test_safety)	8	pub const panic = if (test_safety)
8	std.debug.FullPanic(std.debug.defaultPanic)	9	std.debug.FullPanic(std.debug.defaultPanic)
9	else	10	else
10	std.debug.no_panic;	11	std.debug.no_panic;
...	@@ -19,6 +20,33 @@ pub const std_options_debug_io: std.Io = if (builtin.is_test)	...	@@ -19,6 +20,33 @@ pub const std_options_debug_io: std.Io = if (builtin.is_test)
19	else	20	else
20	unreachable;	21	unreachable;
21		22
		23	pub inline fn symbol(comptime func: *const anyopaque, comptime name: []const u8) void {
		24	@export(func, .{ .name = name, .linkage = linkage, .visibility = visibility });
		25	}
		26
		27	/// For now, we prefer weak linkage because some of the routines we implement here may also be
		28	/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
		29	/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883
		30	pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
		31	.internal
		32	else if (ofmt_c)
		33	.strong
		34	else
		35	.weak;
		36
		37	/// Determines the symbol's visibility to other objects.
		38	/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
		39	/// export it to the host runtime.
		40	pub const visibility: std.builtin.SymbolVisibility = if (linkage == .internal or builtin.link_mode == .dynamic)
		41	.default
		42	else
		43	.hidden;
		44
		45	pub const test_safety = switch (builtin.zig_backend) {
		46	.stage2_aarch64 => false,
		47	else => builtin.is_test,
		48	};
		49
22	comptime {	50	comptime {
23	// Integer routines	51	// Integer routines
24	_ = @import("compiler_rt/count0bits.zig");	52	_ = @import("compiler_rt/count0bits.zig");
...	@@ -276,17 +304,44 @@ comptime {	...	@@ -276,17 +304,44 @@ comptime {
276	_ = @import("compiler_rt/memcpy.zig");	304	_ = @import("compiler_rt/memcpy.zig");
277	_ = @import("compiler_rt/memset.zig");	305	_ = @import("compiler_rt/memset.zig");
278	_ = @import("compiler_rt/memmove.zig");	306	_ = @import("compiler_rt/memmove.zig");
279	_ = @import("compiler_rt/memcmp.zig");	307	symbol(&memcmp, "memcmp");
280	_ = @import("compiler_rt/bcmp.zig");	308	_ = @import("compiler_rt/bcmp.zig");
281	_ = @import("compiler_rt/ssp.zig");	309	_ = @import("compiler_rt/ssp.zig");
282		310	symbol(&strlen, "strlen");
283	_ = @import("compiler_rt/strlen.zig");
284	}	311	}
285		312
286	// Temporarily used for uefi until https://github.com/ziglang/zig/issues/21630 is addressed.	313	// Temporarily used for uefi until https://github.com/ziglang/zig/issues/21630 is addressed.
287	if (!builtin.link_libc and (builtin.os.tag == .windows or builtin.os.tag == .uefi) and (builtin.abi == .none or builtin.abi == .msvc)) {	314	if (!builtin.link_libc and (builtin.os.tag == .windows or builtin.os.tag == .uefi) and (builtin.abi == .none or builtin.abi == .msvc)) {
288	@export(&_fltused, .{ .name = "_fltused", .linkage = common.linkage, .visibility = common.visibility });	315	symbol(&_fltused, "_fltused");
289	}	316	}
290	}	317	}
291		318
292	var _fltused: c_int = 1;	319	var _fltused: c_int = 1;
		320
		321	fn strlen(s: [*:0]const c_char) callconv(.c) usize {
		322	return std.mem.len(s);
		323	}
		324
		325	fn memcmp(vl: []const u8, vr: []const u8, n: usize) callconv(.c) c_int {
		326	var i: usize = 0;
		327	while (i < n) : (i += 1) {
		328	const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]);
		329	if (compared != 0) return compared;
		330	}
		331	return 0;
		332	}
		333
		334	test "memcmp" {
		335	const arr0 = &[_]u8{ 1, 1, 1 };
		336	const arr1 = &[_]u8{ 1, 1, 1 };
		337	const arr2 = &[_]u8{ 1, 0, 1 };
		338	const arr3 = &[_]u8{ 1, 2, 1 };
		339	const arr4 = &[_]u8{ 1, 0xff, 1 };
		340
		341	try std.testing.expect(memcmp(arr0, arr1, 3) == 0);
		342	try std.testing.expect(memcmp(arr0, arr2, 3) > 0);
		343	try std.testing.expect(memcmp(arr0, arr3, 3) < 0);
		344
		345	try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
		346	try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
		347	}

lib/compiler_rt/absvdi2.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const absv = @import("./absv.zig").absv;	2	const absv = @import("./absv.zig").absv;
3		3
4	comptime {	4	comptime {
5	@export(&__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__absvdi2, "__absvdi2");
6	}	6	}
7		7
8	pub fn __absvdi2(a: i64) callconv(.c) i64 {	8	pub fn __absvdi2(a: i64) callconv(.c) i64 {

lib/compiler_rt/absvti2.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const absv = @import("./absv.zig").absv;	2	const absv = @import("./absv.zig").absv;
3		3
4	comptime {	4	comptime {
5	@export(&__absvti2, .{ .name = "__absvti2", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__absvti2, "__absvti2");
6	}	6	}
7		7
8	pub fn __absvti2(a: i128) callconv(.c) i128 {	8	pub fn __absvti2(a: i128) callconv(.c) i128 {

lib/compiler_rt/adddf3.zig+3-2

 @@ -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");
     }
 }

lib/compiler_rt/addsf3.zig+3-2

 @@ -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");
     }
 }

lib/compiler_rt/addvdi3.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const testing = @import("std").testing;	2	const testing = @import("std").testing;
3		3
4	comptime {	4	comptime {
5	@export(&__addvdi3, .{ .name = "__addvdi3", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__addvdi3, "__addvdi3");
6	}	6	}
7		7
8	pub fn __addvdi3(a: i64, b: i64) callconv(.c) i64 {	8	pub fn __addvdi3(a: i64, b: i64) callconv(.c) i64 {

lib/compiler_rt/atomics.zig+82-81

...	@@ -1,10 +1,11 @@	...	@@ -1,10 +1,11 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("./common.zig");
4	const cpu = builtin.cpu;	2	const cpu = builtin.cpu;
5	const arch = cpu.arch;	3	const arch = cpu.arch;
6	const linkage = common.linkage;	4
7	const visibility = common.visibility;	5	const std = @import("std");
		6
		7	const common = @import("./common.zig");
		8	const symbol = @import("../compiler_rt.zig").symbol;
8		9
9	// This parameter is true iff the target architecture supports the bare minimum	10	// This parameter is true iff the target architecture supports the bare minimum
10	// to implement the atomic load/store intrinsics.	11	// to implement the atomic load/store intrinsics.
...	@@ -225,7 +226,7 @@ fn __atomic_store_16(dst: *u128, value: u128, model: i32) callconv(.c) void {	...	@@ -225,7 +226,7 @@ fn __atomic_store_16(dst: *u128, value: u128, model: i32) callconv(.c) void {
225	}	226	}
226		227
227	fn wideUpdate(comptime T: type, ptr: *T, val: T, update: anytype) T {	228	fn wideUpdate(comptime T: type, ptr: *T, val: T, update: anytype) T {
228	const WideAtomic = std.meta.Int(.unsigned, smallest_atomic_fetch_exch_size * 8);	229	const WideAtomic = @Int(.unsigned, smallest_atomic_fetch_exch_size * 8);
229		230
230	const addr = @intFromPtr(ptr);	231	const addr = @intFromPtr(ptr);
231	const wide_addr = addr & ~(@as(T, smallest_atomic_fetch_exch_size) - 1);	232	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 {	...	@@ -535,81 +536,81 @@ fn __atomic_fetch_umin_16(ptr: *u128, val: u128, model: i32) callconv(.c) u128 {
535		536
536	comptime {	537	comptime {
537	if (supports_atomic_ops and builtin.object_format != .c) {	538	if (supports_atomic_ops and builtin.object_format != .c) {
538	@export(&__atomic_load, .{ .name = "__atomic_load", .linkage = linkage, .visibility = visibility });	539	symbol(&__atomic_load, "__atomic_load");
539	@export(&__atomic_store, .{ .name = "__atomic_store", .linkage = linkage, .visibility = visibility });	540	symbol(&__atomic_store, "__atomic_store");
540	@export(&__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage, .visibility = visibility });	541	symbol(&__atomic_exchange, "__atomic_exchange");
541	@export(&__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage, .visibility = visibility });	542	symbol(&__atomic_compare_exchange, "__atomic_compare_exchange");
542		543
543	@export(&__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage, .visibility = visibility });	544	symbol(&__atomic_fetch_add_1, "__atomic_fetch_add_1");
544	@export(&__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage, .visibility = visibility });	545	symbol(&__atomic_fetch_add_2, "__atomic_fetch_add_2");
545	@export(&__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage, .visibility = visibility });	546	symbol(&__atomic_fetch_add_4, "__atomic_fetch_add_4");
546	@export(&__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage, .visibility = visibility });	547	symbol(&__atomic_fetch_add_8, "__atomic_fetch_add_8");
547	@export(&__atomic_fetch_add_16, .{ .name = "__atomic_fetch_add_16", .linkage = linkage, .visibility = visibility });	548	symbol(&__atomic_fetch_add_16, "__atomic_fetch_add_16");
548		549
549	@export(&__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage, .visibility = visibility });	550	symbol(&__atomic_fetch_sub_1, "__atomic_fetch_sub_1");
550	@export(&__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage, .visibility = visibility });	551	symbol(&__atomic_fetch_sub_2, "__atomic_fetch_sub_2");
551	@export(&__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage, .visibility = visibility });	552	symbol(&__atomic_fetch_sub_4, "__atomic_fetch_sub_4");
552	@export(&__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage, .visibility = visibility });	553	symbol(&__atomic_fetch_sub_8, "__atomic_fetch_sub_8");
553	@export(&__atomic_fetch_sub_16, .{ .name = "__atomic_fetch_sub_16", .linkage = linkage, .visibility = visibility });	554	symbol(&__atomic_fetch_sub_16, "__atomic_fetch_sub_16");
554		555
555	@export(&__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage, .visibility = visibility });	556	symbol(&__atomic_fetch_and_1, "__atomic_fetch_and_1");
556	@export(&__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage, .visibility = visibility });	557	symbol(&__atomic_fetch_and_2, "__atomic_fetch_and_2");
557	@export(&__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage, .visibility = visibility });	558	symbol(&__atomic_fetch_and_4, "__atomic_fetch_and_4");
558	@export(&__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage, .visibility = visibility });	559	symbol(&__atomic_fetch_and_8, "__atomic_fetch_and_8");
559	@export(&__atomic_fetch_and_16, .{ .name = "__atomic_fetch_and_16", .linkage = linkage, .visibility = visibility });	560	symbol(&__atomic_fetch_and_16, "__atomic_fetch_and_16");
560		561
561	@export(&__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage, .visibility = visibility });	562	symbol(&__atomic_fetch_or_1, "__atomic_fetch_or_1");
562	@export(&__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage, .visibility = visibility });	563	symbol(&__atomic_fetch_or_2, "__atomic_fetch_or_2");
563	@export(&__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage, .visibility = visibility });	564	symbol(&__atomic_fetch_or_4, "__atomic_fetch_or_4");
564	@export(&__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage, .visibility = visibility });	565	symbol(&__atomic_fetch_or_8, "__atomic_fetch_or_8");
565	@export(&__atomic_fetch_or_16, .{ .name = "__atomic_fetch_or_16", .linkage = linkage, .visibility = visibility });	566	symbol(&__atomic_fetch_or_16, "__atomic_fetch_or_16");
566		567
567	@export(&__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage, .visibility = visibility });	568	symbol(&__atomic_fetch_xor_1, "__atomic_fetch_xor_1");
568	@export(&__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage, .visibility = visibility });	569	symbol(&__atomic_fetch_xor_2, "__atomic_fetch_xor_2");
569	@export(&__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage, .visibility = visibility });	570	symbol(&__atomic_fetch_xor_4, "__atomic_fetch_xor_4");
570	@export(&__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage, .visibility = visibility });	571	symbol(&__atomic_fetch_xor_8, "__atomic_fetch_xor_8");
571	@export(&__atomic_fetch_xor_16, .{ .name = "__atomic_fetch_xor_16", .linkage = linkage, .visibility = visibility });	572	symbol(&__atomic_fetch_xor_16, "__atomic_fetch_xor_16");
572		573
573	@export(&__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage, .visibility = visibility });	574	symbol(&__atomic_fetch_nand_1, "__atomic_fetch_nand_1");
574	@export(&__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage, .visibility = visibility });	575	symbol(&__atomic_fetch_nand_2, "__atomic_fetch_nand_2");
575	@export(&__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage, .visibility = visibility });	576	symbol(&__atomic_fetch_nand_4, "__atomic_fetch_nand_4");
576	@export(&__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage, .visibility = visibility });	577	symbol(&__atomic_fetch_nand_8, "__atomic_fetch_nand_8");
577	@export(&__atomic_fetch_nand_16, .{ .name = "__atomic_fetch_nand_16", .linkage = linkage, .visibility = visibility });	578	symbol(&__atomic_fetch_nand_16, "__atomic_fetch_nand_16");
578		579
579	@export(&__atomic_fetch_umax_1, .{ .name = "__atomic_fetch_umax_1", .linkage = linkage, .visibility = visibility });	580	symbol(&__atomic_fetch_umax_1, "__atomic_fetch_umax_1");
580	@export(&__atomic_fetch_umax_2, .{ .name = "__atomic_fetch_umax_2", .linkage = linkage, .visibility = visibility });	581	symbol(&__atomic_fetch_umax_2, "__atomic_fetch_umax_2");
581	@export(&__atomic_fetch_umax_4, .{ .name = "__atomic_fetch_umax_4", .linkage = linkage, .visibility = visibility });	582	symbol(&__atomic_fetch_umax_4, "__atomic_fetch_umax_4");
582	@export(&__atomic_fetch_umax_8, .{ .name = "__atomic_fetch_umax_8", .linkage = linkage, .visibility = visibility });	583	symbol(&__atomic_fetch_umax_8, "__atomic_fetch_umax_8");
583	@export(&__atomic_fetch_umax_16, .{ .name = "__atomic_fetch_umax_16", .linkage = linkage, .visibility = visibility });	584	symbol(&__atomic_fetch_umax_16, "__atomic_fetch_umax_16");
584		585
585	@export(&__atomic_fetch_umin_1, .{ .name = "__atomic_fetch_umin_1", .linkage = linkage, .visibility = visibility });	586	symbol(&__atomic_fetch_umin_1, "__atomic_fetch_umin_1");
586	@export(&__atomic_fetch_umin_2, .{ .name = "__atomic_fetch_umin_2", .linkage = linkage, .visibility = visibility });	587	symbol(&__atomic_fetch_umin_2, "__atomic_fetch_umin_2");
587	@export(&__atomic_fetch_umin_4, .{ .name = "__atomic_fetch_umin_4", .linkage = linkage, .visibility = visibility });	588	symbol(&__atomic_fetch_umin_4, "__atomic_fetch_umin_4");
588	@export(&__atomic_fetch_umin_8, .{ .name = "__atomic_fetch_umin_8", .linkage = linkage, .visibility = visibility });	589	symbol(&__atomic_fetch_umin_8, "__atomic_fetch_umin_8");
589	@export(&__atomic_fetch_umin_16, .{ .name = "__atomic_fetch_umin_16", .linkage = linkage, .visibility = visibility });	590	symbol(&__atomic_fetch_umin_16, "__atomic_fetch_umin_16");
590		591
591	@export(&__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage, .visibility = visibility });	592	symbol(&__atomic_load_1, "__atomic_load_1");
592	@export(&__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage, .visibility = visibility });	593	symbol(&__atomic_load_2, "__atomic_load_2");
593	@export(&__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage, .visibility = visibility });	594	symbol(&__atomic_load_4, "__atomic_load_4");
594	@export(&__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage, .visibility = visibility });	595	symbol(&__atomic_load_8, "__atomic_load_8");
595	@export(&__atomic_load_16, .{ .name = "__atomic_load_16", .linkage = linkage, .visibility = visibility });	596	symbol(&__atomic_load_16, "__atomic_load_16");
596		597
597	@export(&__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage, .visibility = visibility });	598	symbol(&__atomic_store_1, "__atomic_store_1");
598	@export(&__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage, .visibility = visibility });	599	symbol(&__atomic_store_2, "__atomic_store_2");
599	@export(&__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage, .visibility = visibility });	600	symbol(&__atomic_store_4, "__atomic_store_4");
600	@export(&__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage, .visibility = visibility });	601	symbol(&__atomic_store_8, "__atomic_store_8");
601	@export(&__atomic_store_16, .{ .name = "__atomic_store_16", .linkage = linkage, .visibility = visibility });	602	symbol(&__atomic_store_16, "__atomic_store_16");
602		603
603	@export(&__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage, .visibility = visibility });	604	symbol(&__atomic_exchange_1, "__atomic_exchange_1");
604	@export(&__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage, .visibility = visibility });	605	symbol(&__atomic_exchange_2, "__atomic_exchange_2");
605	@export(&__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage, .visibility = visibility });	606	symbol(&__atomic_exchange_4, "__atomic_exchange_4");
606	@export(&__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage, .visibility = visibility });	607	symbol(&__atomic_exchange_8, "__atomic_exchange_8");
607	@export(&__atomic_exchange_16, .{ .name = "__atomic_exchange_16", .linkage = linkage, .visibility = visibility });	608	symbol(&__atomic_exchange_16, "__atomic_exchange_16");
608		609
609	@export(&__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage, .visibility = visibility });	610	symbol(&__atomic_compare_exchange_1, "__atomic_compare_exchange_1");
610	@export(&__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage, .visibility = visibility });	611	symbol(&__atomic_compare_exchange_2, "__atomic_compare_exchange_2");
611	@export(&__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage, .visibility = visibility });	612	symbol(&__atomic_compare_exchange_4, "__atomic_compare_exchange_4");
612	@export(&__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage, .visibility = visibility });	613	symbol(&__atomic_compare_exchange_8, "__atomic_compare_exchange_8");
613	@export(&__atomic_compare_exchange_16, .{ .name = "__atomic_compare_exchange_16", .linkage = linkage, .visibility = visibility });	614	symbol(&__atomic_compare_exchange_16, "__atomic_compare_exchange_16");
614	}	615	}
615	}	616	}

lib/compiler_rt/aulldiv.zig+4-6

...	@@ -1,15 +1,13 @@	...	@@ -1,15 +1,13 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const arch = builtin.cpu.arch;	2
4	const os = builtin.os.tag;
5	const abi = builtin.abi;
6	const common = @import("common.zig");	3	const common = @import("common.zig");
		4	const symbol = @import("../compiler_rt.zig").symbol;
7		5
8	comptime {	6	comptime {
9	if (common.want_windows_x86_msvc_abi) {	7	if (common.want_windows_x86_msvc_abi) {
10	// Don't let LLVM apply the stdcall name mangling on those MSVC builtins	8	// Don't let LLVM apply the stdcall name mangling on those MSVC builtins
11	@export(&_alldiv, .{ .name = "\x01__alldiv", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&_alldiv, "\x01__alldiv");
12	@export(&_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility });	10	symbol(&_aulldiv, "\x01__aulldiv");
13	}	11	}
14	}	12	}
15		13

lib/compiler_rt/cmpdf2.zig+9-8

...	@@ -2,18 +2,19 @@	...	@@ -2,18 +2,19 @@
2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines	2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
3	const common = @import("./common.zig");	3	const common = @import("./common.zig");
4	const comparef = @import("./comparef.zig");	4	const comparef = @import("./comparef.zig");
		5	const symbol = @import("../compiler_rt.zig").symbol;
5		6
6	comptime {	7	comptime {
7	if (common.want_aeabi) {	8	if (common.want_aeabi) {
8	@export(&__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__aeabi_dcmpeq, "__aeabi_dcmpeq");
9	@export(&__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = common.linkage, .visibility = common.visibility });	10	symbol(&__aeabi_dcmplt, "__aeabi_dcmplt");
10	@export(&__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = common.linkage, .visibility = common.visibility });	11	symbol(&__aeabi_dcmple, "__aeabi_dcmple");
11	} else {	12	} else {
12	@export(&__eqdf2, .{ .name = "__eqdf2", .linkage = common.linkage, .visibility = common.visibility });	13	symbol(&__eqdf2, "__eqdf2");
13	@export(&__nedf2, .{ .name = "__nedf2", .linkage = common.linkage, .visibility = common.visibility });	14	symbol(&__nedf2, "__nedf2");
14	@export(&__ledf2, .{ .name = "__ledf2", .linkage = common.linkage, .visibility = common.visibility });	15	symbol(&__ledf2, "__ledf2");
15	@export(&__cmpdf2, .{ .name = "__cmpdf2", .linkage = common.linkage, .visibility = common.visibility });	16	symbol(&__cmpdf2, "__cmpdf2");
16	@export(&__ltdf2, .{ .name = "__ltdf2", .linkage = common.linkage, .visibility = common.visibility });	17	symbol(&__ltdf2, "__ltdf2");
17	}	18	}
18	}	19	}
19		20

lib/compiler_rt/cmptf2.zig+17-16

...	@@ -2,27 +2,28 @@	...	@@ -2,27 +2,28 @@
2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines	2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
3	const common = @import("./common.zig");	3	const common = @import("./common.zig");
4	const comparef = @import("./comparef.zig");	4	const comparef = @import("./comparef.zig");
		5	const symbol = @import("../compiler_rt.zig").symbol;
5		6
6	comptime {	7	comptime {
7	if (common.want_ppc_abi) {	8	if (common.want_ppc_abi) {
8	@export(&__eqtf2, .{ .name = "__eqkf2", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__eqtf2, "__eqkf2");
9	@export(&__netf2, .{ .name = "__nekf2", .linkage = common.linkage, .visibility = common.visibility });	10	symbol(&__netf2, "__nekf2");
10	@export(&__lttf2, .{ .name = "__ltkf2", .linkage = common.linkage, .visibility = common.visibility });	11	symbol(&__lttf2, "__ltkf2");
11	@export(&__letf2, .{ .name = "__lekf2", .linkage = common.linkage, .visibility = common.visibility });	12	symbol(&__letf2, "__lekf2");
12	} else if (common.want_sparc_abi) {	13	} else if (common.want_sparc_abi) {
13	@export(&_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = common.linkage, .visibility = common.visibility });	14	symbol(&_Qp_cmp, "_Qp_cmp");
14	@export(&_Qp_feq, .{ .name = "_Qp_feq", .linkage = common.linkage, .visibility = common.visibility });	15	symbol(&_Qp_feq, "_Qp_feq");
15	@export(&_Qp_fne, .{ .name = "_Qp_fne", .linkage = common.linkage, .visibility = common.visibility });	16	symbol(&_Qp_fne, "_Qp_fne");
16	@export(&_Qp_flt, .{ .name = "_Qp_flt", .linkage = common.linkage, .visibility = common.visibility });	17	symbol(&_Qp_flt, "_Qp_flt");
17	@export(&_Qp_fle, .{ .name = "_Qp_fle", .linkage = common.linkage, .visibility = common.visibility });	18	symbol(&_Qp_fle, "_Qp_fle");
18	@export(&_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = common.linkage, .visibility = common.visibility });	19	symbol(&_Qp_fgt, "_Qp_fgt");
19	@export(&_Qp_fge, .{ .name = "_Qp_fge", .linkage = common.linkage, .visibility = common.visibility });	20	symbol(&_Qp_fge, "_Qp_fge");
20	}	21	}
21	@export(&__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage, .visibility = common.visibility });	22	symbol(&__eqtf2, "__eqtf2");
22	@export(&__netf2, .{ .name = "__netf2", .linkage = common.linkage, .visibility = common.visibility });	23	symbol(&__netf2, "__netf2");
23	@export(&__letf2, .{ .name = "__letf2", .linkage = common.linkage, .visibility = common.visibility });	24	symbol(&__letf2, "__letf2");
24	@export(&__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage, .visibility = common.visibility });	25	symbol(&__cmptf2, "__cmptf2");
25	@export(&__lttf2, .{ .name = "__lttf2", .linkage = common.linkage, .visibility = common.visibility });	26	symbol(&__lttf2, "__lttf2");
26	}	27	}
27		28
28	/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;	29	/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;

lib/compiler_rt/common.zig+6-20

 @@ -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
+/// Deprecated, everything in common should move to compiler_rt.zig
-/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
+pub const linkage = @import("../compiler_rt.zig").linkage;
-/// 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.
+/// Deprecated, everything in common should move to compiler_rt.zig
-/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
+pub const visibility = @import("../compiler_rt.zig").visibility;
-/// 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 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) {
+/// Deprecated, everything in common should move to compiler_rt.zig
-    .stage2_aarch64 => false,
+pub const test_safety = @import("../compiler_rt.zig").test_safety;
-    else => builtin.is_test,
-};
 /// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
 pub fn F16T(comptime OtherType: type) type {

lib/compiler_rt/cos.zig+9-8

 @@ -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 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 });
+    symbol(&__cosh, "__cosh");
-    @export(&cosf, .{ .name = "cosf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&cosf, "cosf");
-    @export(&cos, .{ .name = "cos", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&cos, "cos");
-    @export(&__cosx, .{ .name = "__cosx", .linkage = common.linkage, .visibility = common.visibility });
+    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 });
+    symbol(&cosq, "cosq");
-    @export(&cosl, .{ .name = "cosl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&cosl, "cosl");
 }
 pub fn __cosh(a: f16) callconv(.c) f16 {

lib/compiler_rt/count0bits.zig+11-11

...	@@ -1,17 +1,17 @@	...	@@ -1,17 +1,17 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2	const std = @import("std");
		3	const symbol = @import("../compiler_rt.zig").symbol;
4		4
5	comptime {	5	comptime {
6	@export(&__clzsi2, .{ .name = "__clzsi2", .linkage = common.linkage, .visibility = common.visibility });	6	symbol(&__clzsi2, "__clzsi2");
7	@export(&__clzdi2, .{ .name = "__clzdi2", .linkage = common.linkage, .visibility = common.visibility });	7	symbol(&__clzdi2, "__clzdi2");
8	@export(&__clzti2, .{ .name = "__clzti2", .linkage = common.linkage, .visibility = common.visibility });	8	symbol(&__clzti2, "__clzti2");
9	@export(&__ctzsi2, .{ .name = "__ctzsi2", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__ctzsi2, "__ctzsi2");
10	@export(&__ctzdi2, .{ .name = "__ctzdi2", .linkage = common.linkage, .visibility = common.visibility });	10	symbol(&__ctzdi2, "__ctzdi2");
11	@export(&__ctzti2, .{ .name = "__ctzti2", .linkage = common.linkage, .visibility = common.visibility });	11	symbol(&__ctzti2, "__ctzti2");
12	@export(&__ffssi2, .{ .name = "__ffssi2", .linkage = common.linkage, .visibility = common.visibility });	12	symbol(&__ffssi2, "__ffssi2");
13	@export(&__ffsdi2, .{ .name = "__ffsdi2", .linkage = common.linkage, .visibility = common.visibility });	13	symbol(&__ffsdi2, "__ffsdi2");
14	@export(&__ffsti2, .{ .name = "__ffsti2", .linkage = common.linkage, .visibility = common.visibility });	14	symbol(&__ffsti2, "__ffsti2");
15	}	15	}
16		16
17	// clz - count leading zeroes	17	// clz - count leading zeroes

lib/compiler_rt/divdc3.zig+2-2

...	@@ -1,10 +1,10 @@	...	@@ -1,10 +1,10 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const divc3 = @import("./divc3.zig");	2	const divc3 = @import("./divc3.zig");
3	const Complex = @import("./mulc3.zig").Complex;	3	const Complex = @import("./mulc3.zig").Complex;
4		4
5	comptime {	5	comptime {
6	if (@import("builtin").zig_backend != .stage2_c) {	6	if (@import("builtin").zig_backend != .stage2_c) {
7	@export(&__divdc3, .{ .name = "__divdc3", .linkage = common.linkage, .visibility = common.visibility });	7	symbol(&__divdc3, "__divdc3");
8	}	8	}
9	}	9	}
10		10

lib/compiler_rt/divdf3.zig+3-4

 @@ -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");
     }
 }

lib/compiler_rt/divhf3.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const divsf3 = @import("./divsf3.zig");	2	const divsf3 = @import("./divsf3.zig");
3		3
4	comptime {	4	comptime {
5	@export(&__divhf3, .{ .name = "__divhf3", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__divhf3, "__divhf3");
6	}	6	}
7		7
8	pub fn __divhf3(a: f16, b: f16) callconv(.c) f16 {	8	pub fn __divhf3(a: f16, b: f16) callconv(.c) f16 {

lib/compiler_rt/divmodei4.zig+7-5

 @@ -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 });
+    symbol(&__divei4, "__divei4");
-    @export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility });
+    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];
 }

lib/compiler_rt/divsc3.zig+2-2

 @@ -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");
     }
 }

lib/compiler_rt/divsf3.zig+3-4

 @@ -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");
     }
 }

lib/compiler_rt/divtc3.zig+3-2

 @@ -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 });
+            symbol(&__divtc3, "__divkc3");
-        @export(&__divtc3, .{ .name = "__divtc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__divtc3, "__divtc3");
     }
 }

lib/compiler_rt/divxc3.zig+2-2

...	@@ -1,10 +1,10 @@	...	@@ -1,10 +1,10 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const divc3 = @import("./divc3.zig");	2	const divc3 = @import("./divc3.zig");
3	const Complex = @import("./mulc3.zig").Complex;	3	const Complex = @import("./mulc3.zig").Complex;
4		4
5	comptime {	5	comptime {
6	if (@import("builtin").zig_backend != .stage2_c) {	6	if (@import("builtin").zig_backend != .stage2_c) {
7	@export(&__divxc3, .{ .name = "__divxc3", .linkage = common.linkage, .visibility = common.visibility });	7	symbol(&__divxc3, "__divxc3");
8	}	8	}
9	}	9	}
10		10

lib/compiler_rt/exp.zig+11-8

 @@ -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 });
+    symbol(&__exph, "__exph");
-    @export(&expf, .{ .name = "expf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&expf, "expf");
-    @export(&exp, .{ .name = "exp", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&exp, "exp");
-    @export(&__expx, .{ .name = "__expx", .linkage = common.linkage, .visibility = common.visibility });
+    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 });
+    symbol(&expq, "expq");
-    @export(&expl, .{ .name = "expl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&expl, "expl");
 }
 pub fn __exph(a: f16) callconv(.c) f16 {

lib/compiler_rt/extenddftf2.zig+4-3

 @@ -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 {

lib/compiler_rt/extendhfdf2.zig+2-1

 @@ -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 {

lib/compiler_rt/extendhfsf2.zig+4-3

 @@ -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 {

lib/compiler_rt/extendsfxf2.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const extend_f80 = @import("./extendf.zig").extend_f80;	2	const extend_f80 = @import("./extendf.zig").extend_f80;
3		3
4	comptime {	4	comptime {
5	@export(&__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__extendsfxf2, "__extendsfxf2");
6	}	6	}
7		7
8	fn __extendsfxf2(a: f32) callconv(.c) f80 {	8	fn __extendsfxf2(a: f32) callconv(.c) f80 {

lib/compiler_rt/extendxftf2.zig+3-2

...	@@ -1,8 +1,9 @@	...	@@ -1,8 +1,9 @@
1	const std = @import("std");	1	const std = @import("std");
2	const common = @import("./common.zig");	2
		3	const symbol = @import("../compiler_rt.zig").symbol;
3		4
4	comptime {	5	comptime {
5	@export(&__extendxftf2, .{ .name = "__extendxftf2", .linkage = common.linkage, .visibility = common.visibility });	6	symbol(&__extendxftf2, "__extendxftf2");
6	}	7	}
7		8
8	fn __extendxftf2(a: f80) callconv(.c) f128 {	9	fn __extendxftf2(a: f80) callconv(.c) f128 {

lib/compiler_rt/fixdfsi.zig+3-2

 @@ -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");
     }
 }

lib/compiler_rt/fixdfti.zig+3-3

 @@ -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");
     }
 }

lib/compiler_rt/fixsfdi.zig+4-3

 @@ -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");
     }
 }

lib/compiler_rt/fixtfdi.zig+4-3

 @@ -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 {

lib/compiler_rt/fixtfsi.zig+4-3

 @@ -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 {

lib/compiler_rt/fixtfti.zig+4-4

 @@ -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 });
+            symbol(&__fixtfti, "__fixkfti");
-        @export(&__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__fixtfti, "__fixtfti");
     }
 }

lib/compiler_rt/fixunsdfei.zig+5-3

...	@@ -1,10 +1,12 @@	...	@@ -1,10 +1,12 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2
		3	const std = @import("std");
		4
		5	const symbol = @import("../compiler_rt.zig").symbol;
4	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;	6	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
5		7
6	comptime {	8	comptime {
7	@export(&__fixunsdfei, .{ .name = "__fixunsdfei", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__fixunsdfei, "__fixunsdfei");
8	}	10	}
9		11
10	pub fn __fixunsdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void {	12	pub fn __fixunsdfei(r: [*]u8, bits: usize, a: f64) callconv(.c) void {

lib/compiler_rt/fixunsdfti.zig+3-3

 @@ -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");
     }
 }

lib/compiler_rt/fixunshfdi.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3		3
4	comptime {	4	comptime {
5	@export(&__fixunshfdi, .{ .name = "__fixunshfdi", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__fixunshfdi, "__fixunshfdi");
6	}	6	}
7		7
8	fn __fixunshfdi(a: f16) callconv(.c) u64 {	8	fn __fixunshfdi(a: f16) callconv(.c) u64 {

lib/compiler_rt/fixunshfei.zig+5-3

...	@@ -1,10 +1,12 @@	...	@@ -1,10 +1,12 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2
		3	const std = @import("std");
		4
		5	const symbol = @import("../compiler_rt.zig").symbol;
4	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;	6	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
5		7
6	comptime {	8	comptime {
7	@export(&__fixunshfei, .{ .name = "__fixunshfei", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__fixunshfei, "__fixunshfei");
8	}	10	}
9		11
10	pub fn __fixunshfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void {	12	pub fn __fixunshfei(r: [*]u8, bits: usize, a: f16) callconv(.c) void {

lib/compiler_rt/fixunshfti.zig+3-3

 @@ -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");
     }
 }

lib/compiler_rt/fixunssfei.zig+5-3

...	@@ -1,10 +1,12 @@	...	@@ -1,10 +1,12 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2
		3	const std = @import("std");
		4
		5	const symbol = @import("../compiler_rt.zig").symbol;
4	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;	6	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
5		7
6	comptime {	8	comptime {
7	@export(&__fixunssfei, .{ .name = "__fixunssfei", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__fixunssfei, "__fixunssfei");
8	}	10	}
9		11
10	pub fn __fixunssfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void {	12	pub fn __fixunssfei(r: [*]u8, bits: usize, a: f32) callconv(.c) void {

lib/compiler_rt/fixunssfti.zig+3-2

 @@ -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");
     }
 }

lib/compiler_rt/fixunstfei.zig+5-3

...	@@ -1,10 +1,12 @@	...	@@ -1,10 +1,12 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2
		3	const std = @import("std");
		4
		5	const symbol = @import("../compiler_rt.zig").symbol;
4	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;	6	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
5		7
6	comptime {	8	comptime {
7	@export(&__fixunstfei, .{ .name = "__fixunstfei", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__fixunstfei, "__fixunstfei");
8	}	10	}
9		11
10	pub fn __fixunstfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void {	12	pub fn __fixunstfei(r: [*]u8, bits: usize, a: f128) callconv(.c) void {

lib/compiler_rt/fixunsxfdi.zig+2-2

 @@ -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 {

lib/compiler_rt/fixunsxfei.zig+2-2

...	@@ -1,10 +1,10 @@	...	@@ -1,10 +1,10 @@
1	const std = @import("std");	1	const std = @import("std");
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
3	const common = @import("common.zig");	3	const symbol = @import("../compiler_rt.zig").symbol;
4	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;	4	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
5		5
6	comptime {	6	comptime {
7	@export(&__fixunsxfei, .{ .name = "__fixunsxfei", .linkage = common.linkage, .visibility = common.visibility });	7	symbol(&__fixunsxfei, "__fixunsxfei");
8	}	8	}
9		9
10	pub fn __fixunsxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void {	10	pub fn __fixunsxfei(r: [*]u8, bits: usize, a: f80) callconv(.c) void {

lib/compiler_rt/fixxfdi.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3		3
4	comptime {	4	comptime {
5	@export(&__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__fixxfdi, "__fixxfdi");
6	}	6	}
7		7
8	fn __fixxfdi(a: f80) callconv(.c) i64 {	8	fn __fixxfdi(a: f80) callconv(.c) i64 {

lib/compiler_rt/fixxfti.zig+4-2

 @@ -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");
     }
 }

lib/compiler_rt/floatdihf.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3		3
4	comptime {	4	comptime {
5	@export(&__floatdihf, .{ .name = "__floatdihf", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__floatdihf, "__floatdihf");
6	}	6	}
7		7
8	fn __floatdihf(a: i64) callconv(.c) f16 {	8	fn __floatdihf(a: i64) callconv(.c) f16 {

lib/compiler_rt/floatdisf.zig+4-4

 @@ -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");
     }
 }

lib/compiler_rt/floatditf.zig+4-3

 @@ -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 {

lib/compiler_rt/floatdixf.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3		3
4	comptime {	4	comptime {
5	@export(&__floatdixf, .{ .name = "__floatdixf", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__floatdixf, "__floatdixf");
6	}	6	}
7		7
8	fn __floatdixf(a: i64) callconv(.c) f80 {	8	fn __floatdixf(a: i64) callconv(.c) f80 {

lib/compiler_rt/floateidf.zig+5-3

...	@@ -1,10 +1,12 @@	...	@@ -1,10 +1,12 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2
		3	const std = @import("std");
		4
4	const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;	5	const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
		6	const symbol = @import("../compiler_rt.zig").symbol;
5		7
6	comptime {	8	comptime {
7	@export(&__floateidf, .{ .name = "__floateidf", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__floateidf, "__floateidf");
8	}	10	}
9		11
10	pub fn __floateidf(a: [*]const u8, bits: usize) callconv(.c) f64 {	12	pub fn __floateidf(a: [*]const u8, bits: usize) callconv(.c) f64 {

lib/compiler_rt/floateixf.zig+5-3

...	@@ -1,10 +1,12 @@	...	@@ -1,10 +1,12 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2
		3	const std = @import("std");
		4
		5	const symbol = @import("../compiler_rt.zig").symbol;
4	const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;	6	const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
5		7
6	comptime {	8	comptime {
7	@export(&__floateixf, .{ .name = "__floateixf", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__floateixf, "__floateixf");
8	}	10	}
9		11
10	pub fn __floateixf(a: [*]const u8, bits: usize) callconv(.c) f80 {	12	pub fn __floateixf(a: [*]const u8, bits: usize) callconv(.c) f80 {

lib/compiler_rt/floatsixf.zig+2-1

 @@ -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 {

lib/compiler_rt/floattidf.zig+3-3

 @@ -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");
     }
 }

lib/compiler_rt/floattisf.zig+3-3

 @@ -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");
     }
 }

lib/compiler_rt/floattitf.zig+4-4

 @@ -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 });
+            symbol(&__floattitf, "__floattikf");
-        @export(&__floattitf, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floattitf, "__floattitf");
     }
 }

lib/compiler_rt/floatundidf.zig+4-4

 @@ -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");
     }
 }

lib/compiler_rt/floatuneitf.zig+5-3

...	@@ -1,10 +1,12 @@	...	@@ -1,10 +1,12 @@
1	const std = @import("std");
2	const builtin = @import("builtin");	1	const builtin = @import("builtin");
3	const common = @import("common.zig");	2
		3	const std = @import("std");
		4
		5	const symbol = @import("../compiler_rt.zig").symbol;
4	const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;	6	const floatFromBigInt = @import("float_from_int.zig").floatFromBigInt;
5		7
6	comptime {	8	comptime {
7	@export(&__floatuneitf, .{ .name = "__floatuneitf", .linkage = common.linkage, .visibility = common.visibility });	9	symbol(&__floatuneitf, "__floatuneitf");
8	}	10	}
9		11
10	pub fn __floatuneitf(a: [*]const u8, bits: usize) callconv(.c) f128 {	12	pub fn __floatuneitf(a: [*]const u8, bits: usize) callconv(.c) f128 {

lib/compiler_rt/floatunsihf.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3		3
4	comptime {	4	comptime {
5	@export(&__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__floatunsihf, "__floatunsihf");
6	}	6	}
7		7
8	pub fn __floatunsihf(a: u32) callconv(.c) f16 {	8	pub fn __floatunsihf(a: u32) callconv(.c) f16 {

lib/compiler_rt/floatunsisf.zig+3-2

 @@ -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");
     }
 }

lib/compiler_rt/floatunsitf.zig+4-3

 @@ -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 {

lib/compiler_rt/floatuntidf.zig+3-3

 @@ -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");
     }
 }

lib/compiler_rt/floatuntihf.zig+3-3

 @@ -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");
     }
 }

lib/compiler_rt/floatuntitf.zig+4-4

 @@ -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 });
+            symbol(&__floatuntitf, "__floatuntikf");
-        @export(&__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__floatuntitf, "__floatuntitf");
     }
 }

lib/compiler_rt/floor_ceil.zig+15-14

...	@@ -15,29 +15,30 @@ const mem = std.mem;	...	@@ -15,29 +15,30 @@ const mem = std.mem;
15	const expect = std.testing.expect;	15	const expect = std.testing.expect;
16		16
17	const common = @import("common.zig");	17	const common = @import("common.zig");
		18	const symbol = @import("../compiler_rt.zig").symbol;
18		19
19	comptime {	20	comptime {
20	// floor	21	// floor
21	@export(&__floorh, .{ .name = "__floorh", .linkage = common.linkage, .visibility = common.visibility });	22	symbol(&__floorh, "__floorh");
22	@export(&floorf, .{ .name = "floorf", .linkage = common.linkage, .visibility = common.visibility });	23	symbol(&floorf, "floorf");
23	@export(&floor, .{ .name = "floor", .linkage = common.linkage, .visibility = common.visibility });	24	symbol(&floor, "floor");
24	@export(&__floorx, .{ .name = "__floorx", .linkage = common.linkage, .visibility = common.visibility });	25	symbol(&__floorx, "__floorx");
25	if (common.want_ppc_abi) {	26	if (common.want_ppc_abi) {
26	@export(&floorq, .{ .name = "floorf128", .linkage = common.linkage, .visibility = common.visibility });	27	symbol(&floorq, "floorf128");
27	}	28	}
28	@export(&floorq, .{ .name = "floorq", .linkage = common.linkage, .visibility = common.visibility });	29	symbol(&floorq, "floorq");
29	@export(&floorl, .{ .name = "floorl", .linkage = common.linkage, .visibility = common.visibility });	30	symbol(&floorl, "floorl");
30		31
31	// ceil	32	// ceil
32	@export(&__ceilh, .{ .name = "__ceilh", .linkage = common.linkage, .visibility = common.visibility });	33	symbol(&__ceilh, "__ceilh");
33	@export(&ceilf, .{ .name = "ceilf", .linkage = common.linkage, .visibility = common.visibility });	34	symbol(&ceilf, "ceilf");
34	@export(&ceil, .{ .name = "ceil", .linkage = common.linkage, .visibility = common.visibility });	35	symbol(&ceil, "ceil");
35	@export(&__ceilx, .{ .name = "__ceilx", .linkage = common.linkage, .visibility = common.visibility });	36	symbol(&__ceilx, "__ceilx");
36	if (common.want_ppc_abi) {	37	if (common.want_ppc_abi) {
37	@export(&ceilq, .{ .name = "ceilf128", .linkage = common.linkage, .visibility = common.visibility });	38	symbol(&ceilq, "ceilf128");
38	}	39	}
39	@export(&ceilq, .{ .name = "ceilq", .linkage = common.linkage, .visibility = common.visibility });	40	symbol(&ceilq, "ceilq");
40	@export(&ceill, .{ .name = "ceill", .linkage = common.linkage, .visibility = common.visibility });	41	symbol(&ceill, "ceill");
41	}	42	}
42		43
43	pub fn __floorh(x: f16) callconv(.c) f16 {	44	pub fn __floorh(x: f16) callconv(.c) f16 {

lib/compiler_rt/gedf2.zig+5-4

 @@ -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 });
+        symbol(&__aeabi_dcmpge, "__aeabi_dcmpge");
-        @export(&__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__aeabi_dcmpgt, "__aeabi_dcmpgt");
     } else {
-        @export(&__gedf2, .{ .name = "__gedf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__gedf2, "__gedf2");
-        @export(&__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__gtdf2, "__gtdf2");
     }
 }

lib/compiler_rt/gehf2.zig+3-3

...	@@ -1,11 +1,11 @@	...	@@ -1,11 +1,11 @@
1	///! The quoted behavior definitions are from	1	///! The quoted behavior definitions are from
2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines	2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
3	const common = @import("./common.zig");	3	const symbol = @import("../compiler_rt.zig").symbol;
4	const comparef = @import("./comparef.zig");	4	const comparef = @import("./comparef.zig");
5		5
6	comptime {	6	comptime {
7	@export(&__gehf2, .{ .name = "__gehf2", .linkage = common.linkage, .visibility = common.visibility });	7	symbol(&__gehf2, "__gehf2");
8	@export(&__gthf2, .{ .name = "__gthf2", .linkage = common.linkage, .visibility = common.visibility });	8	symbol(&__gthf2, "__gthf2");
9	}	9	}
10		10
11	/// "These functions return a value greater than or equal to zero if neither	11	/// "These functions return a value greater than or equal to zero if neither

lib/compiler_rt/gexf2.zig+3-3

...	@@ -1,9 +1,9 @@	...	@@ -1,9 +1,9 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const comparef = @import("./comparef.zig");	2	const comparef = @import("./comparef.zig");
3		3
4	comptime {	4	comptime {
5	@export(&__gexf2, .{ .name = "__gexf2", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__gexf2, "__gexf2");
6	@export(&__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage, .visibility = common.visibility });	6	symbol(&__gtxf2, "__gtxf2");
7	}	7	}
8		8
9	fn __gexf2(a: f80, b: f80) callconv(.c) i32 {	9	fn __gexf2(a: f80, b: f80) callconv(.c) i32 {

lib/compiler_rt/int.zig+19-16

...	@@ -1,34 +1,37 @@	...	@@ -1,34 +1,37 @@
1	//! Builtin functions that operate on integer types	1	//! Builtin functions that operate on integer types
2		2
3	const builtin = @import("builtin");	3	const builtin = @import("builtin");
		4	const arch = builtin.cpu.arch;
		5
4	const std = @import("std");	6	const std = @import("std");
5	const testing = std.testing;	7	const testing = std.testing;
6	const maxInt = std.math.maxInt;	8	const maxInt = std.math.maxInt;
7	const minInt = std.math.minInt;	9	const minInt = std.math.minInt;
8	const arch = builtin.cpu.arch;	10
9	const common = @import("common.zig");	11	const common = @import("common.zig");
		12	const symbol = @import("../compiler_rt.zig").symbol;
10	const udivmod = @import("udivmod.zig").udivmod;	13	const udivmod = @import("udivmod.zig").udivmod;
11	const __divti3 = @import("divti3.zig").__divti3;	14	const __divti3 = @import("divti3.zig").__divti3;
12		15
13	comptime {	16	comptime {
14	@export(&__divmodti4, .{ .name = "__divmodti4", .linkage = common.linkage, .visibility = common.visibility });	17	symbol(&__divmodti4, "__divmodti4");
15	@export(&__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = common.linkage, .visibility = common.visibility });	18	symbol(&__udivmoddi4, "__udivmoddi4");
16	@export(&__divmoddi4, .{ .name = "__divmoddi4", .linkage = common.linkage, .visibility = common.visibility });	19	symbol(&__divmoddi4, "__divmoddi4");
17	if (common.want_aeabi) {	20	if (common.want_aeabi) {
18	@export(&__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = common.linkage, .visibility = common.visibility });	21	symbol(&__aeabi_idiv, "__aeabi_idiv");
19	@export(&__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = common.linkage, .visibility = common.visibility });	22	symbol(&__aeabi_uidiv, "__aeabi_uidiv");
20	} else {	23	} else {
21	@export(&__divsi3, .{ .name = "__divsi3", .linkage = common.linkage, .visibility = common.visibility });	24	symbol(&__divsi3, "__divsi3");
22	@export(&__udivsi3, .{ .name = "__udivsi3", .linkage = common.linkage, .visibility = common.visibility });	25	symbol(&__udivsi3, "__udivsi3");
23	}	26	}
24	@export(&__divdi3, .{ .name = "__divdi3", .linkage = common.linkage, .visibility = common.visibility });	27	symbol(&__divdi3, "__divdi3");
25	@export(&__udivdi3, .{ .name = "__udivdi3", .linkage = common.linkage, .visibility = common.visibility });	28	symbol(&__udivdi3, "__udivdi3");
26	@export(&__modsi3, .{ .name = "__modsi3", .linkage = common.linkage, .visibility = common.visibility });	29	symbol(&__modsi3, "__modsi3");
27	@export(&__moddi3, .{ .name = "__moddi3", .linkage = common.linkage, .visibility = common.visibility });	30	symbol(&__moddi3, "__moddi3");
28	@export(&__umodsi3, .{ .name = "__umodsi3", .linkage = common.linkage, .visibility = common.visibility });	31	symbol(&__umodsi3, "__umodsi3");
29	@export(&__umoddi3, .{ .name = "__umoddi3", .linkage = common.linkage, .visibility = common.visibility });	32	symbol(&__umoddi3, "__umoddi3");
30	@export(&__divmodsi4, .{ .name = "__divmodsi4", .linkage = common.linkage, .visibility = common.visibility });	33	symbol(&__divmodsi4, "__divmodsi4");
31	@export(&__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = common.linkage, .visibility = common.visibility });	34	symbol(&__udivmodsi4, "__udivmodsi4");
32	}	35	}
33		36
34	pub fn __divmodti4(a: i128, b: i128, rem: *i128) callconv(.c) i128 {	37	pub fn __divmodti4(a: i128, b: i128, rem: *i128) callconv(.c) i128 {

lib/compiler_rt/log.zig+9-9

...	@@ -5,23 +5,23 @@	...	@@ -5,23 +5,23 @@
5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/log.c?h=1b76ff0767d01df72f692806ee5adee13c67ef88	5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/log.c?h=1b76ff0767d01df72f692806ee5adee13c67ef88
6		6
7	const std = @import("std");	7	const std = @import("std");
8	const builtin = @import("builtin");
9	const math = std.math;	8	const math = std.math;
10	const expect = std.testing.expect;	9	const expect = std.testing.expect;
11	const expectEqual = std.testing.expectEqual;	10	const expectEqual = std.testing.expectEqual;
12	const arch = builtin.cpu.arch;	11
13	const common = @import("common.zig");	12	const common = @import("common.zig");
		13	const symbol = @import("../compiler_rt.zig").symbol;
14		14
15	comptime {	15	comptime {
16	@export(&__logh, .{ .name = "__logh", .linkage = common.linkage, .visibility = common.visibility });	16	symbol(&__logh, "__logh");
17	@export(&logf, .{ .name = "logf", .linkage = common.linkage, .visibility = common.visibility });	17	symbol(&logf, "logf");
18	@export(&log, .{ .name = "log", .linkage = common.linkage, .visibility = common.visibility });	18	symbol(&log, "log");
19	@export(&__logx, .{ .name = "__logx", .linkage = common.linkage, .visibility = common.visibility });	19	symbol(&__logx, "__logx");
20	if (common.want_ppc_abi) {	20	if (common.want_ppc_abi) {
21	@export(&logq, .{ .name = "logf128", .linkage = common.linkage, .visibility = common.visibility });	21	symbol(&logq, "logf128");
22	}	22	}
23	@export(&logq, .{ .name = "logq", .linkage = common.linkage, .visibility = common.visibility });	23	symbol(&logq, "logq");
24	@export(&logl, .{ .name = "logl", .linkage = common.linkage, .visibility = common.visibility });	24	symbol(&logl, "logl");
25	}	25	}
26		26
27	pub fn __logh(a: f16) callconv(.c) f16 {	27	pub fn __logh(a: f16) callconv(.c) f16 {

lib/compiler_rt/log10.zig+9-9

...	@@ -5,24 +5,24 @@	...	@@ -5,24 +5,24 @@
5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c	5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c
6		6
7	const std = @import("std");	7	const std = @import("std");
8	const builtin = @import("builtin");
9	const math = std.math;	8	const math = std.math;
10	const expect = std.testing.expect;	9	const expect = std.testing.expect;
11	const expectEqual = std.testing.expectEqual;	10	const expectEqual = std.testing.expectEqual;
12	const maxInt = std.math.maxInt;	11	const maxInt = std.math.maxInt;
13	const arch = builtin.cpu.arch;	12
14	const common = @import("common.zig");	13	const common = @import("common.zig");
		14	const symbol = @import("../compiler_rt.zig").symbol;
15		15
16	comptime {	16	comptime {
17	@export(&__log10h, .{ .name = "__log10h", .linkage = common.linkage, .visibility = common.visibility });	17	symbol(&__log10h, "__log10h");
18	@export(&log10f, .{ .name = "log10f", .linkage = common.linkage, .visibility = common.visibility });	18	symbol(&log10f, "log10f");
19	@export(&log10, .{ .name = "log10", .linkage = common.linkage, .visibility = common.visibility });	19	symbol(&log10, "log10");
20	@export(&__log10x, .{ .name = "__log10x", .linkage = common.linkage, .visibility = common.visibility });	20	symbol(&__log10x, "__log10x");
21	if (common.want_ppc_abi) {	21	if (common.want_ppc_abi) {
22	@export(&log10q, .{ .name = "log10f128", .linkage = common.linkage, .visibility = common.visibility });	22	symbol(&log10q, "log10f128");
23	}	23	}
24	@export(&log10q, .{ .name = "log10q", .linkage = common.linkage, .visibility = common.visibility });	24	symbol(&log10q, "log10q");
25	@export(&log10l, .{ .name = "log10l", .linkage = common.linkage, .visibility = common.visibility });	25	symbol(&log10l, "log10l");
26	}	26	}
27		27
28	pub fn __log10h(a: f16) callconv(.c) f16 {	28	pub fn __log10h(a: f16) callconv(.c) f16 {

lib/compiler_rt/memcmp.zig deleted-30

...	@@ -1,30 +0,0 @@
1	const std = @import("std");
2	const common = @import("./common.zig");
3
4	comptime {
5	@export(&memcmp, .{ .name = "memcmp", .linkage = common.linkage, .visibility = common.visibility });
6	}
7
8	pub fn memcmp(vl: []const u8, vr: []const u8, n: usize) callconv(.c) c_int {
9	var i: usize = 0;
10	while (i < n) : (i += 1) {
11	const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]);
12	if (compared != 0) return compared;
13	}
14	return 0;
15	}
16
17	test "memcmp" {
18	const arr0 = &[_]u8{ 1, 1, 1 };
19	const arr1 = &[_]u8{ 1, 1, 1 };
20	const arr2 = &[_]u8{ 1, 0, 1 };
21	const arr3 = &[_]u8{ 1, 2, 1 };
22	const arr4 = &[_]u8{ 1, 0xff, 1 };
23
24	try std.testing.expect(memcmp(arr0, arr1, 3) == 0);
25	try std.testing.expect(memcmp(arr0, arr2, 3) > 0);
26	try std.testing.expect(memcmp(arr0, arr3, 3) < 0);
27
28	try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
29	try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
30	}

lib/compiler_rt/muldc3.zig+2-2

 @@ -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");
     }
 }

lib/compiler_rt/muldf3.zig+3-2

 @@ -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");
     }
 }

lib/compiler_rt/mulsc3.zig+2-2

...	@@ -1,9 +1,9 @@	...	@@ -1,9 +1,9 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const mulc3 = @import("./mulc3.zig");	2	const mulc3 = @import("./mulc3.zig");
3		3
4	comptime {	4	comptime {
5	if (@import("builtin").zig_backend != .stage2_c) {	5	if (@import("builtin").zig_backend != .stage2_c) {
6	@export(&__mulsc3, .{ .name = "__mulsc3", .linkage = common.linkage, .visibility = common.visibility });	6	symbol(&__mulsc3, "__mulsc3");
7	}	7	}
8	}	8	}
9		9

lib/compiler_rt/multc3.zig+3-2

 @@ -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 });
+            symbol(&__multc3, "__mulkc3");
-        @export(&__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility });
+        symbol(&__multc3, "__multc3");
     }
 }

lib/compiler_rt/mulvsi3.zig+4-3

 @@ -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 {

lib/compiler_rt/negtf2.zig+3-2

 @@ -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 });
+        symbol(&__negtf2, "__negkf2");
-    @export(&__negtf2, .{ .name = "__negtf2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__negtf2, "__negtf2");
 }
 fn __negtf2(a: f128) callconv(.c) f128 {

lib/compiler_rt/parity.zig+5-8

...	@@ -1,14 +1,11 @@	...	@@ -1,14 +1,11 @@
1	//! parity - if number of bits set is even => 0, else => 1	1	//! parity - if number of bits set is even => 0, else => 1
2	//! - pariytXi2_generic for big and little endian	2	//! - pariytXi2_generic for big and little endian
3		3	const symbol = @import("../compiler_rt.zig").symbol;
4	const std = @import("std");
5	const builtin = @import("builtin");
6	const common = @import("common.zig");
7		4
8	comptime {	5	comptime {
9	@export(&__paritysi2, .{ .name = "__paritysi2", .linkage = common.linkage, .visibility = common.visibility });	6	symbol(&__paritysi2, "__paritysi2");
10	@export(&__paritydi2, .{ .name = "__paritydi2", .linkage = common.linkage, .visibility = common.visibility });	7	symbol(&__paritydi2, "__paritydi2");
11	@export(&__parityti2, .{ .name = "__parityti2", .linkage = common.linkage, .visibility = common.visibility });	8	symbol(&__parityti2, "__parityti2");
12	}	9	}
13		10
14	pub fn __paritysi2(a: i32) callconv(.c) i32 {	11	pub fn __paritysi2(a: i32) callconv(.c) i32 {
...	@@ -24,7 +21,7 @@ pub fn __parityti2(a: i128) callconv(.c) i32 {	...	@@ -24,7 +21,7 @@ pub fn __parityti2(a: i128) callconv(.c) i32 {
24	}	21	}
25		22
26	inline fn parityXi2(comptime T: type, a: T) i32 {	23	inline fn parityXi2(comptime T: type, a: T) i32 {
27	var x: std.meta.Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);	24	var x: @Int(.unsigned, @typeInfo(T).int.bits) = @bitCast(a);
28	// Bit Twiddling Hacks: Compute parity in parallel	25	// Bit Twiddling Hacks: Compute parity in parallel
29	comptime var shift: u8 = @bitSizeOf(T) / 2;	26	comptime var shift: u8 = @bitSizeOf(T) / 2;
30	inline while (shift > 2) {	27	inline while (shift > 2) {

lib/compiler_rt/popcount.zig+4-6

 @@ -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 symbol = @import("../compiler_rt.zig").symbol;
-const std = @import("std");
-const common = @import("common.zig");
 comptime {
-    @export(&__popcountsi2, .{ .name = "__popcountsi2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__popcountsi2, "__popcountsi2");
-    @export(&__popcountdi2, .{ .name = "__popcountdi2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__popcountdi2, "__popcountdi2");
-    @export(&__popcountti2, .{ .name = "__popcountti2", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&__popcountti2, "__popcountti2");
 }
 pub fn __popcountsi2(a: i32) callconv(.c) i32 {

lib/compiler_rt/powiXf2.zig+7-8

...	@@ -3,18 +3,17 @@	...	@@ -3,18 +3,17 @@
3	//! Multiplication order (left-to-right or right-to-left) does not matter for	3	//! Multiplication order (left-to-right or right-to-left) does not matter for
4	//! error propagation and this method is optimized for performance, not accuracy.	4	//! error propagation and this method is optimized for performance, not accuracy.
5		5
6	const builtin = @import("builtin");
7	const common = @import("common.zig");	6	const common = @import("common.zig");
8	const std = @import("std");	7	const symbol = @import("../compiler_rt.zig").symbol;
9		8
10	comptime {	9	comptime {
11	@export(&__powihf2, .{ .name = "__powihf2", .linkage = common.linkage, .visibility = common.visibility });	10	symbol(&__powihf2, "__powihf2");
12	@export(&__powisf2, .{ .name = "__powisf2", .linkage = common.linkage, .visibility = common.visibility });	11	symbol(&__powisf2, "__powisf2");
13	@export(&__powidf2, .{ .name = "__powidf2", .linkage = common.linkage, .visibility = common.visibility });	12	symbol(&__powidf2, "__powidf2");
14	if (common.want_ppc_abi)	13	if (common.want_ppc_abi)
15	@export(&__powitf2, .{ .name = "__powikf2", .linkage = common.linkage, .visibility = common.visibility });	14	symbol(&__powitf2, "__powikf2");
16	@export(&__powitf2, .{ .name = "__powitf2", .linkage = common.linkage, .visibility = common.visibility });	15	symbol(&__powitf2, "__powitf2");
17	@export(&__powixf2, .{ .name = "__powixf2", .linkage = common.linkage, .visibility = common.visibility });	16	symbol(&__powixf2, "__powixf2");
18	}	17	}
19		18
20	inline fn powiXf2(comptime FT: type, a: FT, b: i32) FT {	19	inline fn powiXf2(comptime FT: type, a: FT, b: i32) FT {

lib/compiler_rt/sin.zig+9-10

 @@ -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 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 });
+    symbol(&__sinh, "__sinh");
-    @export(&sinf, .{ .name = "sinf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&sinf, "sinf");
-    @export(&sin, .{ .name = "sin", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&sin, "sin");
-    @export(&__sinx, .{ .name = "__sinx", .linkage = common.linkage, .visibility = common.visibility });
+    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 });
+    symbol(&sinq, "sinq");
-    @export(&sinl, .{ .name = "sinl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&sinl, "sinl");
 }
 pub fn __sinh(x: f16) callconv(.c) f16 {

lib/compiler_rt/strlen.zig deleted-10

...	@@ -1,10 +0,0 @@
1	const std = @import("std");
2	const common = @import("common.zig");
3
4	comptime {
5	@export(&strlen, .{ .name = "strlen", .linkage = common.linkage, .visibility = common.visibility });
6	}
7
8	fn strlen(s: [*:0]const c_char) callconv(.c) usize {
9	return std.mem.len(s);
10	}

lib/compiler_rt/subdf3.zig+3-2

 @@ -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");
     }
 }

lib/compiler_rt/subvdi3.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const testing = @import("std").testing;	2	const testing = @import("std").testing;
3		3
4	comptime {	4	comptime {
5	@export(&__subvdi3, .{ .name = "__subvdi3", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__subvdi3, "__subvdi3");
6	}	6	}
7		7
8	pub fn __subvdi3(a: i64, b: i64) callconv(.c) i64 {	8	pub fn __subvdi3(a: i64, b: i64) callconv(.c) i64 {

lib/compiler_rt/subxf3.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const std = @import("std");	1	const std = @import("std");
2	const common = @import("./common.zig");	2	const symbol = @import("../compiler_rt.zig").symbol;
3		3
4	comptime {	4	comptime {
5	@export(&__subxf3, .{ .name = "__subxf3", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__subxf3, "__subxf3");
6	}	6	}
7		7
8	fn __subxf3(a: f80, b: f80) callconv(.c) f80 {	8	fn __subxf3(a: f80, b: f80) callconv(.c) f80 {

lib/compiler_rt/tan.zig+8-7

...	@@ -17,17 +17,18 @@ const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;	...	@@ -17,17 +17,18 @@ const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
17		17
18	const arch = builtin.cpu.arch;	18	const arch = builtin.cpu.arch;
19	const common = @import("common.zig");	19	const common = @import("common.zig");
		20	const symbol = @import("../compiler_rt.zig").symbol;
20		21
21	comptime {	22	comptime {
22	@export(&__tanh, .{ .name = "__tanh", .linkage = common.linkage, .visibility = common.visibility });	23	symbol(&__tanh, "__tanh");
23	@export(&tanf, .{ .name = "tanf", .linkage = common.linkage, .visibility = common.visibility });	24	symbol(&tanf, "tanf");
24	@export(&tan, .{ .name = "tan", .linkage = common.linkage, .visibility = common.visibility });	25	symbol(&tan, "tan");
25	@export(&__tanx, .{ .name = "__tanx", .linkage = common.linkage, .visibility = common.visibility });	26	symbol(&__tanx, "__tanx");
26	if (common.want_ppc_abi) {	27	if (common.want_ppc_abi) {
27	@export(&tanq, .{ .name = "tanf128", .linkage = common.linkage, .visibility = common.visibility });	28	symbol(&tanq, "tanf128");
28	}	29	}
29	@export(&tanq, .{ .name = "tanq", .linkage = common.linkage, .visibility = common.visibility });	30	symbol(&tanq, "tanq");
30	@export(&tanl, .{ .name = "tanl", .linkage = common.linkage, .visibility = common.visibility });	31	symbol(&tanl, "tanl");
31	}	32	}
32		33
33	pub fn __tanh(x: f16) callconv(.c) f16 {	34	pub fn __tanh(x: f16) callconv(.c) f16 {

lib/compiler_rt/trunc.zig+11-8

 @@ -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 });
+    symbol(&__trunch, "__trunch");
-    @export(&truncf, .{ .name = "truncf", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&truncf, "truncf");
-    @export(&trunc, .{ .name = "trunc", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&trunc, "trunc");
-    @export(&__truncx, .{ .name = "__truncx", .linkage = common.linkage, .visibility = common.visibility });
+    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 });
+    symbol(&truncq, "truncq");
-    @export(&truncl, .{ .name = "truncl", .linkage = common.linkage, .visibility = common.visibility });
+    symbol(&truncl, "truncl");
 }
 pub fn __trunch(x: f16) callconv(.c) f16 {

lib/compiler_rt/truncdfhf2.zig+3-2

 @@ -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) {

lib/compiler_rt/trunctfhf2.zig+2-1

 @@ -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) {

lib/compiler_rt/trunctfsf2.zig+4-3

 @@ -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 {

lib/compiler_rt/truncxfdf2.zig+2-2

...	@@ -1,8 +1,8 @@	...	@@ -1,8 +1,8 @@
1	const common = @import("./common.zig");	1	const symbol = @import("../compiler_rt.zig").symbol;
2	const trunc_f80 = @import("./truncf.zig").trunc_f80;	2	const trunc_f80 = @import("./truncf.zig").trunc_f80;
3		3
4	comptime {	4	comptime {
5	@export(&__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = common.linkage, .visibility = common.visibility });	5	symbol(&__truncxfdf2, "__truncxfdf2");
6	}	6	}
7		7
8	fn __truncxfdf2(a: f80) callconv(.c) f64 {	8	fn __truncxfdf2(a: f80) callconv(.c) f64 {

lib/compiler_rt/truncxfhf2.zig+2-1

 @@ -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) {

lib/compiler_rt/truncxfsf2.zig+2-2

 @@ -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 {

lib/compiler_rt/udivmodei4.zig+8-6

 @@ -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 });
+    symbol(&__udivei4, "__udivei4");
-    @export(&__umodei4, .{ .name = "__umodei4", .linkage = common.linkage, .visibility = common.visibility });
+    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];

lib/compiler_rt/unorddf2.zig+3-2

 @@ -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");
     }
 }

author	Andrew Kelley <andrew@ziglang.org> 2026-02-08 23:55:26-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-02-09 20:04:17+01:00
log	04c180c8e57fecdf3478de966f32b8a1f65ad202
tree	b34c0d325d8c78c0aea7c672e7768705fc8dfd45
parent	6473dc22fc1659df218ade897647c0658e0ebec9

compiler_rt: partial cleanup