Commit 04c180c8e57fecdf3478de966f32b8a1f65ad202 | zig

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

introduce `symbol` helper function and partially migrate to using it

95 files changed, 544 insertions(+), 492 deletions(-)

lib
- compiler_rt.zig
- compiler_rt

lib/compiler_rt.zig+62-7

...	...	@@ -1,10 +1,11 @@
1		const std = @import("std");
2	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	6	/// Avoid dragging in the runtime safety mechanisms into this .o file, unless
6	7	/// we're trying to test compiler-rt.
7		pub const panic = if (common.test_safety)
	8	pub const panic = if (test_safety)
8	9	std.debug.FullPanic(std.debug.defaultPanic)
9	10	else
10	11	std.debug.no_panic;
...	...	@@ -19,6 +20,33 @@ pub const std_options_debug_io: std.Io = if (builtin.is_test)
19	20	else
20	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	50	comptime {
23	51	// Integer routines
24	52	_ = @import("compiler_rt/count0bits.zig");
...	...	@@ -276,17 +304,44 @@ comptime {
276	304	_ = @import("compiler_rt/memcpy.zig");
277	305	_ = @import("compiler_rt/memset.zig");
278	306	_ = @import("compiler_rt/memmove.zig");
279		_ = @import("compiler_rt/memcmp.zig");
	307	symbol(&memcmp, "memcmp");
280	308	_ = @import("compiler_rt/bcmp.zig");
281	309	_ = @import("compiler_rt/ssp.zig");
282
283		_ = @import("compiler_rt/strlen.zig");
	310	symbol(&strlen, "strlen");
284	311	}
285	312
286	313	// Temporarily used for uefi until https://github.com/ziglang/zig/issues/21630 is addressed.
287	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	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		const common = @import("./common.zig");
	1	const symbol = @import("../compiler_rt.zig").symbol;
2	2	const absv = @import("./absv.zig").absv;
3	3
4	4	comptime {
5		@export(&__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage, .visibility = common.visibility });
	5	symbol(&__absvdi2, "__absvdi2");
6	6	}
7	7
8	8	pub fn __absvdi2(a: i64) callconv(.c) i64 {

lib/compiler_rt/absvti2.zig+2-2

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

lib/compiler_rt/adddf3.zig+3-2

...	...	@@ -1,11 +1,12 @@
1	1	const common = @import("./common.zig");
2	2	const addf3 = @import("./addf3.zig").addf3;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_dadd, "__aeabi_dadd");
7	8	} else {
8		@export(&__adddf3, .{ .name = "__adddf3", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__adddf3, "__adddf3");
9	10	}
10	11	}
11	12

lib/compiler_rt/addsf3.zig+3-2

...	...	@@ -1,11 +1,12 @@
1	1	const common = @import("./common.zig");
2	2	const addf3 = @import("./addf3.zig").addf3;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_fadd, "__aeabi_fadd");
7	8	} else {
8		@export(&__addsf3, .{ .name = "__addsf3", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__addsf3, "__addsf3");
9	10	}
10	11	}
11	12

lib/compiler_rt/addvdi3.zig+2-2

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

lib/compiler_rt/atomics.zig+82-81

...	...	@@ -1,10 +1,11 @@
1		const std = @import("std");
2	1	const builtin = @import("builtin");
3		const common = @import("./common.zig");
4	2	const cpu = builtin.cpu;
5	3	const arch = cpu.arch;
6		const linkage = common.linkage;
7		const visibility = common.visibility;
	4
	5	const std = @import("std");
	6
	7	const common = @import("./common.zig");
	8	const symbol = @import("../compiler_rt.zig").symbol;
8	9
9	10	// This parameter is true iff the target architecture supports the bare minimum
10	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	226	}
226	227
227	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	231	const addr = @intFromPtr(ptr);
231	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	536
536	537	comptime {
537	538	if (supports_atomic_ops and builtin.object_format != .c) {
538		@export(&__atomic_load, .{ .name = "__atomic_load", .linkage = linkage, .visibility = visibility });
539		@export(&__atomic_store, .{ .name = "__atomic_store", .linkage = linkage, .visibility = visibility });
540		@export(&__atomic_exchange, .{ .name = "__atomic_exchange", .linkage = linkage, .visibility = visibility });
541		@export(&__atomic_compare_exchange, .{ .name = "__atomic_compare_exchange", .linkage = linkage, .visibility = visibility });
542
543		@export(&__atomic_fetch_add_1, .{ .name = "__atomic_fetch_add_1", .linkage = linkage, .visibility = visibility });
544		@export(&__atomic_fetch_add_2, .{ .name = "__atomic_fetch_add_2", .linkage = linkage, .visibility = visibility });
545		@export(&__atomic_fetch_add_4, .{ .name = "__atomic_fetch_add_4", .linkage = linkage, .visibility = visibility });
546		@export(&__atomic_fetch_add_8, .{ .name = "__atomic_fetch_add_8", .linkage = linkage, .visibility = visibility });
547		@export(&__atomic_fetch_add_16, .{ .name = "__atomic_fetch_add_16", .linkage = linkage, .visibility = visibility });
548
549		@export(&__atomic_fetch_sub_1, .{ .name = "__atomic_fetch_sub_1", .linkage = linkage, .visibility = visibility });
550		@export(&__atomic_fetch_sub_2, .{ .name = "__atomic_fetch_sub_2", .linkage = linkage, .visibility = visibility });
551		@export(&__atomic_fetch_sub_4, .{ .name = "__atomic_fetch_sub_4", .linkage = linkage, .visibility = visibility });
552		@export(&__atomic_fetch_sub_8, .{ .name = "__atomic_fetch_sub_8", .linkage = linkage, .visibility = visibility });
553		@export(&__atomic_fetch_sub_16, .{ .name = "__atomic_fetch_sub_16", .linkage = linkage, .visibility = visibility });
554
555		@export(&__atomic_fetch_and_1, .{ .name = "__atomic_fetch_and_1", .linkage = linkage, .visibility = visibility });
556		@export(&__atomic_fetch_and_2, .{ .name = "__atomic_fetch_and_2", .linkage = linkage, .visibility = visibility });
557		@export(&__atomic_fetch_and_4, .{ .name = "__atomic_fetch_and_4", .linkage = linkage, .visibility = visibility });
558		@export(&__atomic_fetch_and_8, .{ .name = "__atomic_fetch_and_8", .linkage = linkage, .visibility = visibility });
559		@export(&__atomic_fetch_and_16, .{ .name = "__atomic_fetch_and_16", .linkage = linkage, .visibility = visibility });
560
561		@export(&__atomic_fetch_or_1, .{ .name = "__atomic_fetch_or_1", .linkage = linkage, .visibility = visibility });
562		@export(&__atomic_fetch_or_2, .{ .name = "__atomic_fetch_or_2", .linkage = linkage, .visibility = visibility });
563		@export(&__atomic_fetch_or_4, .{ .name = "__atomic_fetch_or_4", .linkage = linkage, .visibility = visibility });
564		@export(&__atomic_fetch_or_8, .{ .name = "__atomic_fetch_or_8", .linkage = linkage, .visibility = visibility });
565		@export(&__atomic_fetch_or_16, .{ .name = "__atomic_fetch_or_16", .linkage = linkage, .visibility = visibility });
566
567		@export(&__atomic_fetch_xor_1, .{ .name = "__atomic_fetch_xor_1", .linkage = linkage, .visibility = visibility });
568		@export(&__atomic_fetch_xor_2, .{ .name = "__atomic_fetch_xor_2", .linkage = linkage, .visibility = visibility });
569		@export(&__atomic_fetch_xor_4, .{ .name = "__atomic_fetch_xor_4", .linkage = linkage, .visibility = visibility });
570		@export(&__atomic_fetch_xor_8, .{ .name = "__atomic_fetch_xor_8", .linkage = linkage, .visibility = visibility });
571		@export(&__atomic_fetch_xor_16, .{ .name = "__atomic_fetch_xor_16", .linkage = linkage, .visibility = visibility });
572
573		@export(&__atomic_fetch_nand_1, .{ .name = "__atomic_fetch_nand_1", .linkage = linkage, .visibility = visibility });
574		@export(&__atomic_fetch_nand_2, .{ .name = "__atomic_fetch_nand_2", .linkage = linkage, .visibility = visibility });
575		@export(&__atomic_fetch_nand_4, .{ .name = "__atomic_fetch_nand_4", .linkage = linkage, .visibility = visibility });
576		@export(&__atomic_fetch_nand_8, .{ .name = "__atomic_fetch_nand_8", .linkage = linkage, .visibility = visibility });
577		@export(&__atomic_fetch_nand_16, .{ .name = "__atomic_fetch_nand_16", .linkage = linkage, .visibility = visibility });
578
579		@export(&__atomic_fetch_umax_1, .{ .name = "__atomic_fetch_umax_1", .linkage = linkage, .visibility = visibility });
580		@export(&__atomic_fetch_umax_2, .{ .name = "__atomic_fetch_umax_2", .linkage = linkage, .visibility = visibility });
581		@export(&__atomic_fetch_umax_4, .{ .name = "__atomic_fetch_umax_4", .linkage = linkage, .visibility = visibility });
582		@export(&__atomic_fetch_umax_8, .{ .name = "__atomic_fetch_umax_8", .linkage = linkage, .visibility = visibility });
583		@export(&__atomic_fetch_umax_16, .{ .name = "__atomic_fetch_umax_16", .linkage = linkage, .visibility = visibility });
584
585		@export(&__atomic_fetch_umin_1, .{ .name = "__atomic_fetch_umin_1", .linkage = linkage, .visibility = visibility });
586		@export(&__atomic_fetch_umin_2, .{ .name = "__atomic_fetch_umin_2", .linkage = linkage, .visibility = visibility });
587		@export(&__atomic_fetch_umin_4, .{ .name = "__atomic_fetch_umin_4", .linkage = linkage, .visibility = visibility });
588		@export(&__atomic_fetch_umin_8, .{ .name = "__atomic_fetch_umin_8", .linkage = linkage, .visibility = visibility });
589		@export(&__atomic_fetch_umin_16, .{ .name = "__atomic_fetch_umin_16", .linkage = linkage, .visibility = visibility });
590
591		@export(&__atomic_load_1, .{ .name = "__atomic_load_1", .linkage = linkage, .visibility = visibility });
592		@export(&__atomic_load_2, .{ .name = "__atomic_load_2", .linkage = linkage, .visibility = visibility });
593		@export(&__atomic_load_4, .{ .name = "__atomic_load_4", .linkage = linkage, .visibility = visibility });
594		@export(&__atomic_load_8, .{ .name = "__atomic_load_8", .linkage = linkage, .visibility = visibility });
595		@export(&__atomic_load_16, .{ .name = "__atomic_load_16", .linkage = linkage, .visibility = visibility });
596
597		@export(&__atomic_store_1, .{ .name = "__atomic_store_1", .linkage = linkage, .visibility = visibility });
598		@export(&__atomic_store_2, .{ .name = "__atomic_store_2", .linkage = linkage, .visibility = visibility });
599		@export(&__atomic_store_4, .{ .name = "__atomic_store_4", .linkage = linkage, .visibility = visibility });
600		@export(&__atomic_store_8, .{ .name = "__atomic_store_8", .linkage = linkage, .visibility = visibility });
601		@export(&__atomic_store_16, .{ .name = "__atomic_store_16", .linkage = linkage, .visibility = visibility });
602
603		@export(&__atomic_exchange_1, .{ .name = "__atomic_exchange_1", .linkage = linkage, .visibility = visibility });
604		@export(&__atomic_exchange_2, .{ .name = "__atomic_exchange_2", .linkage = linkage, .visibility = visibility });
605		@export(&__atomic_exchange_4, .{ .name = "__atomic_exchange_4", .linkage = linkage, .visibility = visibility });
606		@export(&__atomic_exchange_8, .{ .name = "__atomic_exchange_8", .linkage = linkage, .visibility = visibility });
607		@export(&__atomic_exchange_16, .{ .name = "__atomic_exchange_16", .linkage = linkage, .visibility = visibility });
608
609		@export(&__atomic_compare_exchange_1, .{ .name = "__atomic_compare_exchange_1", .linkage = linkage, .visibility = visibility });
610		@export(&__atomic_compare_exchange_2, .{ .name = "__atomic_compare_exchange_2", .linkage = linkage, .visibility = visibility });
611		@export(&__atomic_compare_exchange_4, .{ .name = "__atomic_compare_exchange_4", .linkage = linkage, .visibility = visibility });
612		@export(&__atomic_compare_exchange_8, .{ .name = "__atomic_compare_exchange_8", .linkage = linkage, .visibility = visibility });
613		@export(&__atomic_compare_exchange_16, .{ .name = "__atomic_compare_exchange_16", .linkage = linkage, .visibility = visibility });
	539	symbol(&__atomic_load, "__atomic_load");
	540	symbol(&__atomic_store, "__atomic_store");
	541	symbol(&__atomic_exchange, "__atomic_exchange");
	542	symbol(&__atomic_compare_exchange, "__atomic_compare_exchange");
	543
	544	symbol(&__atomic_fetch_add_1, "__atomic_fetch_add_1");
	545	symbol(&__atomic_fetch_add_2, "__atomic_fetch_add_2");
	546	symbol(&__atomic_fetch_add_4, "__atomic_fetch_add_4");
	547	symbol(&__atomic_fetch_add_8, "__atomic_fetch_add_8");
	548	symbol(&__atomic_fetch_add_16, "__atomic_fetch_add_16");
	549
	550	symbol(&__atomic_fetch_sub_1, "__atomic_fetch_sub_1");
	551	symbol(&__atomic_fetch_sub_2, "__atomic_fetch_sub_2");
	552	symbol(&__atomic_fetch_sub_4, "__atomic_fetch_sub_4");
	553	symbol(&__atomic_fetch_sub_8, "__atomic_fetch_sub_8");
	554	symbol(&__atomic_fetch_sub_16, "__atomic_fetch_sub_16");
	555
	556	symbol(&__atomic_fetch_and_1, "__atomic_fetch_and_1");
	557	symbol(&__atomic_fetch_and_2, "__atomic_fetch_and_2");
	558	symbol(&__atomic_fetch_and_4, "__atomic_fetch_and_4");
	559	symbol(&__atomic_fetch_and_8, "__atomic_fetch_and_8");
	560	symbol(&__atomic_fetch_and_16, "__atomic_fetch_and_16");
	561
	562	symbol(&__atomic_fetch_or_1, "__atomic_fetch_or_1");
	563	symbol(&__atomic_fetch_or_2, "__atomic_fetch_or_2");
	564	symbol(&__atomic_fetch_or_4, "__atomic_fetch_or_4");
	565	symbol(&__atomic_fetch_or_8, "__atomic_fetch_or_8");
	566	symbol(&__atomic_fetch_or_16, "__atomic_fetch_or_16");
	567
	568	symbol(&__atomic_fetch_xor_1, "__atomic_fetch_xor_1");
	569	symbol(&__atomic_fetch_xor_2, "__atomic_fetch_xor_2");
	570	symbol(&__atomic_fetch_xor_4, "__atomic_fetch_xor_4");
	571	symbol(&__atomic_fetch_xor_8, "__atomic_fetch_xor_8");
	572	symbol(&__atomic_fetch_xor_16, "__atomic_fetch_xor_16");
	573
	574	symbol(&__atomic_fetch_nand_1, "__atomic_fetch_nand_1");
	575	symbol(&__atomic_fetch_nand_2, "__atomic_fetch_nand_2");
	576	symbol(&__atomic_fetch_nand_4, "__atomic_fetch_nand_4");
	577	symbol(&__atomic_fetch_nand_8, "__atomic_fetch_nand_8");
	578	symbol(&__atomic_fetch_nand_16, "__atomic_fetch_nand_16");
	579
	580	symbol(&__atomic_fetch_umax_1, "__atomic_fetch_umax_1");
	581	symbol(&__atomic_fetch_umax_2, "__atomic_fetch_umax_2");
	582	symbol(&__atomic_fetch_umax_4, "__atomic_fetch_umax_4");
	583	symbol(&__atomic_fetch_umax_8, "__atomic_fetch_umax_8");
	584	symbol(&__atomic_fetch_umax_16, "__atomic_fetch_umax_16");
	585
	586	symbol(&__atomic_fetch_umin_1, "__atomic_fetch_umin_1");
	587	symbol(&__atomic_fetch_umin_2, "__atomic_fetch_umin_2");
	588	symbol(&__atomic_fetch_umin_4, "__atomic_fetch_umin_4");
	589	symbol(&__atomic_fetch_umin_8, "__atomic_fetch_umin_8");
	590	symbol(&__atomic_fetch_umin_16, "__atomic_fetch_umin_16");
	591
	592	symbol(&__atomic_load_1, "__atomic_load_1");
	593	symbol(&__atomic_load_2, "__atomic_load_2");
	594	symbol(&__atomic_load_4, "__atomic_load_4");
	595	symbol(&__atomic_load_8, "__atomic_load_8");
	596	symbol(&__atomic_load_16, "__atomic_load_16");
	597
	598	symbol(&__atomic_store_1, "__atomic_store_1");
	599	symbol(&__atomic_store_2, "__atomic_store_2");
	600	symbol(&__atomic_store_4, "__atomic_store_4");
	601	symbol(&__atomic_store_8, "__atomic_store_8");
	602	symbol(&__atomic_store_16, "__atomic_store_16");
	603
	604	symbol(&__atomic_exchange_1, "__atomic_exchange_1");
	605	symbol(&__atomic_exchange_2, "__atomic_exchange_2");
	606	symbol(&__atomic_exchange_4, "__atomic_exchange_4");
	607	symbol(&__atomic_exchange_8, "__atomic_exchange_8");
	608	symbol(&__atomic_exchange_16, "__atomic_exchange_16");
	609
	610	symbol(&__atomic_compare_exchange_1, "__atomic_compare_exchange_1");
	611	symbol(&__atomic_compare_exchange_2, "__atomic_compare_exchange_2");
	612	symbol(&__atomic_compare_exchange_4, "__atomic_compare_exchange_4");
	613	symbol(&__atomic_compare_exchange_8, "__atomic_compare_exchange_8");
	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		const std = @import("std");
2	1	const builtin = @import("builtin");
3		const arch = builtin.cpu.arch;
4		const os = builtin.os.tag;
5		const abi = builtin.abi;
	2
6	3	const common = @import("common.zig");
	4	const symbol = @import("../compiler_rt.zig").symbol;
7	5
8	6	comptime {
9	7	if (common.want_windows_x86_msvc_abi) {
10	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 });
12		@export(&_aulldiv, .{ .name = "\x01__aulldiv", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&_alldiv, "\x01__alldiv");
	10	symbol(&_aulldiv, "\x01__aulldiv");
13	11	}
14	12	}
15	13

lib/compiler_rt/cmpdf2.zig+9-8

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

lib/compiler_rt/cmptf2.zig+17-16

...	...	@@ -2,27 +2,28 @@
2	2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
3	3	const common = @import("./common.zig");
4	4	const comparef = @import("./comparef.zig");
	5	const symbol = @import("../compiler_rt.zig").symbol;
5	6
6	7	comptime {
7	8	if (common.want_ppc_abi) {
8		@export(&__eqtf2, .{ .name = "__eqkf2", .linkage = common.linkage, .visibility = common.visibility });
9		@export(&__netf2, .{ .name = "__nekf2", .linkage = common.linkage, .visibility = common.visibility });
10		@export(&__lttf2, .{ .name = "__ltkf2", .linkage = common.linkage, .visibility = common.visibility });
11		@export(&__letf2, .{ .name = "__lekf2", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__eqtf2, "__eqkf2");
	10	symbol(&__netf2, "__nekf2");
	11	symbol(&__lttf2, "__ltkf2");
	12	symbol(&__letf2, "__lekf2");
12	13	} else if (common.want_sparc_abi) {
13		@export(&_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = common.linkage, .visibility = common.visibility });
14		@export(&_Qp_feq, .{ .name = "_Qp_feq", .linkage = common.linkage, .visibility = common.visibility });
15		@export(&_Qp_fne, .{ .name = "_Qp_fne", .linkage = common.linkage, .visibility = common.visibility });
16		@export(&_Qp_flt, .{ .name = "_Qp_flt", .linkage = common.linkage, .visibility = common.visibility });
17		@export(&_Qp_fle, .{ .name = "_Qp_fle", .linkage = common.linkage, .visibility = common.visibility });
18		@export(&_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = common.linkage, .visibility = common.visibility });
19		@export(&_Qp_fge, .{ .name = "_Qp_fge", .linkage = common.linkage, .visibility = common.visibility });
	14	symbol(&_Qp_cmp, "_Qp_cmp");
	15	symbol(&_Qp_feq, "_Qp_feq");
	16	symbol(&_Qp_fne, "_Qp_fne");
	17	symbol(&_Qp_flt, "_Qp_flt");
	18	symbol(&_Qp_fle, "_Qp_fle");
	19	symbol(&_Qp_fgt, "_Qp_fgt");
	20	symbol(&_Qp_fge, "_Qp_fge");
20	21	}
21		@export(&__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage, .visibility = common.visibility });
22		@export(&__netf2, .{ .name = "__netf2", .linkage = common.linkage, .visibility = common.visibility });
23		@export(&__letf2, .{ .name = "__letf2", .linkage = common.linkage, .visibility = common.visibility });
24		@export(&__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage, .visibility = common.visibility });
25		@export(&__lttf2, .{ .name = "__lttf2", .linkage = common.linkage, .visibility = common.visibility });
	22	symbol(&__eqtf2, "__eqtf2");
	23	symbol(&__netf2, "__netf2");
	24	symbol(&__letf2, "__letf2");
	25	symbol(&__cmptf2, "__cmptf2");
	26	symbol(&__lttf2, "__lttf2");
26	27	}
27	28
28	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");
3	3	const native_endian = builtin.cpu.arch.endian();
4	4	const ofmt_c = builtin.object_format == .c;
5	5
6		/// For now, we prefer weak linkage because some of the routines we implement here may also be
7		/// provided by system/dynamic libc. Eventually we should be more disciplined about this on a
8		/// per-symbol, per-target basis: https://github.com/ziglang/zig/issues/11883
9		pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
10		.internal
11		else if (ofmt_c)
12		.strong
13		else
14		.weak;
	6	/// Deprecated, everything in common should move to compiler_rt.zig
	7	pub const linkage = @import("../compiler_rt.zig").linkage;
15	8
16		/// Determines the symbol's visibility to other objects.
17		/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
18		/// export it to the host runtime.
19		pub const visibility: std.builtin.SymbolVisibility = if (linkage == .internal or builtin.link_mode == .dynamic)
20		.default
21		else
22		.hidden;
	9	/// Deprecated, everything in common should move to compiler_rt.zig
	10	pub const visibility = @import("../compiler_rt.zig").visibility;
23	11
24	12	pub const PreferredLoadStoreElement = element: {
25	13	if (std.simd.suggestVectorLength(u8)) \|vec_size\| {
...	...	@@ -121,10 +109,8 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) {
121	109
122	110	pub const want_sparc_abi = builtin.cpu.arch.isSPARC();
123	111
124		pub const test_safety = switch (builtin.zig_backend) {
125		.stage2_aarch64 => false,
126		else => builtin.is_test,
127		};
	112	/// Deprecated, everything in common should move to compiler_rt.zig
	113	pub const test_safety = @import("../compiler_rt.zig").test_safety;
128	114
129	115	/// This seems to mostly correspond to `clang::TargetInfo::HasFloat16`.
130	116	pub fn F16T(comptime OtherType: type) type {

lib/compiler_rt/cos.zig+9-8

...	...	@@ -2,22 +2,23 @@ const std = @import("std");
2	2	const math = std.math;
3	3	const mem = std.mem;
4	4	const expect = std.testing.expect;
5		const common = @import("common.zig");
6	5
	6	const common = @import("common.zig");
	7	const symbol = @import("../compiler_rt.zig").symbol;
7	8	const trig = @import("trig.zig");
8	9	const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
9	10	const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
10	11
11	12	comptime {
12		@export(&__cosh, .{ .name = "__cosh", .linkage = common.linkage, .visibility = common.visibility });
13		@export(&cosf, .{ .name = "cosf", .linkage = common.linkage, .visibility = common.visibility });
14		@export(&cos, .{ .name = "cos", .linkage = common.linkage, .visibility = common.visibility });
15		@export(&__cosx, .{ .name = "__cosx", .linkage = common.linkage, .visibility = common.visibility });
	13	symbol(&__cosh, "__cosh");
	14	symbol(&cosf, "cosf");
	15	symbol(&cos, "cos");
	16	symbol(&__cosx, "__cosx");
16	17	if (common.want_ppc_abi) {
17		@export(&cosq, .{ .name = "cosf128", .linkage = common.linkage, .visibility = common.visibility });
	18	symbol(&cosq, "cosf128");
18	19	}
19		@export(&cosq, .{ .name = "cosq", .linkage = common.linkage, .visibility = common.visibility });
20		@export(&cosl, .{ .name = "cosl", .linkage = common.linkage, .visibility = common.visibility });
	20	symbol(&cosq, "cosq");
	21	symbol(&cosl, "cosl");
21	22	}
22	23
23	24	pub fn __cosh(a: f16) callconv(.c) f16 {

lib/compiler_rt/count0bits.zig+11-11

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

lib/compiler_rt/divdc3.zig+2-2

...	...	@@ -1,10 +1,10 @@
1		const common = @import("./common.zig");
	1	const symbol = @import("../compiler_rt.zig").symbol;
2	2	const divc3 = @import("./divc3.zig");
3	3	const Complex = @import("./mulc3.zig").Complex;
4	4
5	5	comptime {
6	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 @@
3	3	//! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divdf3.c
4	4
5	5	const std = @import("std");
6		const builtin = @import("builtin");
7		const arch = builtin.cpu.arch;
8	6	const common = @import("common.zig");
	7	const symbol = @import("../compiler_rt.zig").symbol;
9	8
10	9	const normalize = common.normalize;
11	10	const wideMultiply = common.wideMultiply;
12	11
13	12	comptime {
14	13	if (common.want_aeabi) {
15		@export(&__aeabi_ddiv, .{ .name = "__aeabi_ddiv", .linkage = common.linkage, .visibility = common.visibility });
	14	symbol(&__aeabi_ddiv, "__aeabi_ddiv");
16	15	} else {
17		@export(&__divdf3, .{ .name = "__divdf3", .linkage = common.linkage, .visibility = common.visibility });
	16	symbol(&__divdf3, "__divdf3");
18	17	}
19	18	}
20	19

lib/compiler_rt/divhf3.zig+2-2

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

lib/compiler_rt/divmodei4.zig+7-5

...	...	@@ -1,15 +1,17 @@
1		const std = @import("std");
2	1	const builtin = @import("builtin");
	2	const endian = builtin.cpu.arch.endian();
	3
	4	const std = @import("std");
	5
3	6	const common = @import("common.zig");
4	7	const udivmod = @import("udivmodei4.zig").divmod;
	8	const symbol = @import("../compiler_rt.zig").symbol;
5	9
6	10	comptime {
7		@export(&__divei4, .{ .name = "__divei4", .linkage = common.linkage, .visibility = common.visibility });
8		@export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__divei4, "__divei4");
	12	symbol(&__modei4, "__modei4");
9	13	}
10	14
11		const endian = builtin.cpu.arch.endian();
12
13	15	inline fn limb(x: []u32, i: usize) *u32 {
14	16	return if (endian == .little) &x[i] else &x[x.len - 1 - i];
15	17	}

lib/compiler_rt/divsc3.zig+2-2

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

lib/compiler_rt/divsf3.zig+3-4

...	...	@@ -3,17 +3,16 @@
3	3	//! https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/divsf3.c
4	4
5	5	const std = @import("std");
6		const builtin = @import("builtin");
7		const arch = builtin.cpu.arch;
8	6
9	7	const common = @import("common.zig");
	8	const symbol = @import("../compiler_rt.zig").symbol;
10	9	const normalize = common.normalize;
11	10
12	11	comptime {
13	12	if (common.want_aeabi) {
14		@export(&__aeabi_fdiv, .{ .name = "__aeabi_fdiv", .linkage = common.linkage, .visibility = common.visibility });
	13	symbol(&__aeabi_fdiv, "__aeabi_fdiv");
15	14	} else {
16		@export(&__divsf3, .{ .name = "__divsf3", .linkage = common.linkage, .visibility = common.visibility });
	15	symbol(&__divsf3, "__divsf3");
17	16	}
18	17	}
19	18

lib/compiler_rt/divtc3.zig+3-2

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

lib/compiler_rt/divxc3.zig+2-2

...	...	@@ -1,10 +1,10 @@
1		const common = @import("./common.zig");
	1	const symbol = @import("../compiler_rt.zig").symbol;
2	2	const divc3 = @import("./divc3.zig");
3	3	const Complex = @import("./mulc3.zig").Complex;
4	4
5	5	comptime {
6	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 @@
4	4	// https://git.musl-libc.org/cgit/musl/tree/src/math/expf.c
5	5	// https://git.musl-libc.org/cgit/musl/tree/src/math/exp.c
6	6
7		const std = @import("std");
8	7	const builtin = @import("builtin");
9	8	const arch = builtin.cpu.arch;
	9
	10	const std = @import("std");
10	11	const math = std.math;
11	12	const mem = std.mem;
12	13	const expect = std.testing.expect;
13	14	const expectEqual = std.testing.expectEqual;
	15
14	16	const common = @import("common.zig");
	17	const symbol = @import("../compiler_rt.zig").symbol;
15	18
16	19	comptime {
17		@export(&__exph, .{ .name = "__exph", .linkage = common.linkage, .visibility = common.visibility });
18		@export(&expf, .{ .name = "expf", .linkage = common.linkage, .visibility = common.visibility });
19		@export(&exp, .{ .name = "exp", .linkage = common.linkage, .visibility = common.visibility });
20		@export(&__expx, .{ .name = "__expx", .linkage = common.linkage, .visibility = common.visibility });
	20	symbol(&__exph, "__exph");
	21	symbol(&expf, "expf");
	22	symbol(&exp, "exp");
	23	symbol(&__expx, "__expx");
21	24	if (common.want_ppc_abi) {
22		@export(&expq, .{ .name = "expf128", .linkage = common.linkage, .visibility = common.visibility });
	25	symbol(&expq, "expf128");
23	26	}
24		@export(&expq, .{ .name = "expq", .linkage = common.linkage, .visibility = common.visibility });
25		@export(&expl, .{ .name = "expl", .linkage = common.linkage, .visibility = common.visibility });
	27	symbol(&expq, "expq");
	28	symbol(&expl, "expl");
26	29	}
27	30
28	31	pub fn __exph(a: f16) callconv(.c) f16 {

lib/compiler_rt/extenddftf2.zig+4-3

...	...	@@ -1,13 +1,14 @@
1	1	const common = @import("./common.zig");
2	2	const extendf = @import("./extendf.zig").extendf;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_ppc_abi) {
6		@export(&__extenddftf2, .{ .name = "__extenddfkf2", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__extenddftf2, "__extenddfkf2");
7	8	} else if (common.want_sparc_abi) {
8		@export(&_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&_Qp_dtoq, "_Qp_dtoq");
9	10	}
10		@export(&__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__extenddftf2, "__extenddftf2");
11	12	}
12	13
13	14	pub fn __extenddftf2(a: f64) callconv(.c) f128 {

lib/compiler_rt/extendhfdf2.zig+2-1

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

lib/compiler_rt/extendhfsf2.zig+4-3

...	...	@@ -1,13 +1,14 @@
1	1	const common = @import("./common.zig");
2	2	const extendf = @import("./extendf.zig").extendf;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.gnu_f16_abi) {
6		@export(&__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__gnu_h2f_ieee, "__gnu_h2f_ieee");
7	8	} else if (common.want_aeabi) {
8		@export(&__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__aeabi_h2f, "__aeabi_h2f");
9	10	}
10		@export(&__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__extendhfsf2, "__extendhfsf2");
11	12	}
12	13
13	14	pub fn __extendhfsf2(a: common.F16T(f32)) callconv(.c) f32 {

lib/compiler_rt/extendsfxf2.zig+2-2

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

lib/compiler_rt/extendxftf2.zig+3-2

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

lib/compiler_rt/fixdfsi.zig+3-2

...	...	@@ -1,11 +1,12 @@
1	1	const common = @import("./common.zig");
2	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_d2iz, "__aeabi_d2iz");
7	8	} else {
8		@export(&__fixdfsi, .{ .name = "__fixdfsi", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__fixdfsi, "__fixdfsi");
9	10	}
10	11	}
11	12

lib/compiler_rt/fixdfti.zig+3-3

...	...	@@ -1,12 +1,12 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
3	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__fixdfti_windows_x86_64, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__fixdfti_windows_x86_64, "__fixdfti");
8	8	} else {
9		@export(&__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__fixdfti, "__fixdfti");
10	10	}
11	11	}
12	12

lib/compiler_rt/fixsfdi.zig+4-3

...	...	@@ -1,15 +1,16 @@
1	1	const builtin = @import("builtin");
2	2	const common = @import("./common.zig");
3	3	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	4	const symbol = @import("../compiler_rt.zig").symbol;
4	5
5	6	comptime {
6	7	if (common.want_aeabi) {
7		@export(&__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage, .visibility = common.visibility });
	8	symbol(&__aeabi_f2lz, "__aeabi_f2lz");
8	9	} else {
9	10	if (common.want_windows_arm_abi) {
10		@export(&__fixsfdi, .{ .name = "__stoi64", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__fixsfdi, "__stoi64");
11	12	}
12		@export(&__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage, .visibility = common.visibility });
	13	symbol(&__fixsfdi, "__fixsfdi");
13	14	}
14	15	}
15	16

lib/compiler_rt/fixtfdi.zig+4-3

...	...	@@ -1,13 +1,14 @@
1	1	const common = @import("./common.zig");
2	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_ppc_abi) {
6		@export(&__fixtfdi, .{ .name = "__fixkfdi", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__fixtfdi, "__fixkfdi");
7	8	} else if (common.want_sparc_abi) {
8		@export(&_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&_Qp_qtox, "_Qp_qtox");
9	10	}
10		@export(&__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__fixtfdi, "__fixtfdi");
11	12	}
12	13
13	14	pub fn __fixtfdi(a: f128) callconv(.c) i64 {

lib/compiler_rt/fixtfsi.zig+4-3

...	...	@@ -1,13 +1,14 @@
1	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
2	3	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3	4
4	5	comptime {
5	6	if (common.want_ppc_abi) {
6		@export(&__fixtfsi, .{ .name = "__fixkfsi", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__fixtfsi, "__fixkfsi");
7	8	} else if (common.want_sparc_abi) {
8		@export(&_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&_Qp_qtoi, "_Qp_qtoi");
9	10	}
10		@export(&__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__fixtfsi, "__fixtfsi");
11	12	}
12	13
13	14	pub fn __fixtfsi(a: f128) callconv(.c) i32 {

lib/compiler_rt/fixtfti.zig+4-4

...	...	@@ -1,14 +1,14 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
3	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__fixtfti_windows_x86_64, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__fixtfti_windows_x86_64, "__fixtfti");
8	8	} else {
9	9	if (common.want_ppc_abi)
10		@export(&__fixtfti, .{ .name = "__fixkfti", .linkage = common.linkage, .visibility = common.visibility });
11		@export(&__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage, .visibility = common.visibility });
	10	symbol(&__fixtfti, "__fixkfti");
	11	symbol(&__fixtfti, "__fixtfti");
12	12	}
13	13	}
14	14

lib/compiler_rt/fixunsdfei.zig+5-3

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

lib/compiler_rt/fixunsdfti.zig+3-3

...	...	@@ -1,12 +1,12 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
3	3	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__fixunsdfti_windows_x86_64, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti");
8	8	} else {
9		@export(&__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__fixunsdfti, "__fixunsdfti");
10	10	}
11	11	}
12	12

lib/compiler_rt/fixunshfdi.zig+2-2

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

lib/compiler_rt/fixunshfei.zig+5-3

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

lib/compiler_rt/fixunshfti.zig+3-3

...	...	@@ -1,12 +1,12 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
3	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__fixunshfti_windows_x86_64, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__fixunshfti_windows_x86_64, "__fixunshfti");
8	8	} else {
9		@export(&__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__fixunshfti, "__fixunshfti");
10	10	}
11	11	}
12	12

lib/compiler_rt/fixunssfei.zig+5-3

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

lib/compiler_rt/fixunssfti.zig+3-2

...	...	@@ -1,12 +1,13 @@
1	1	const builtin = @import("builtin");
2	2	const common = @import("./common.zig");
3	3	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	4	const symbol = @import("../compiler_rt.zig").symbol;
4	5
5	6	comptime {
6	7	if (common.want_windows_v2u64_abi) {
7		@export(&__fixunssfti_windows_x86_64, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
	8	symbol(&__fixunssfti_windows_x86_64, "__fixunssfti");
8	9	} else {
9		@export(&__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage, .visibility = common.visibility });
	10	symbol(&__fixunssfti, "__fixunssfti");
10	11	}
11	12	}
12	13

lib/compiler_rt/fixunstfei.zig+5-3

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

lib/compiler_rt/fixunsxfdi.zig+2-2

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

lib/compiler_rt/fixunsxfei.zig+2-2

...	...	@@ -1,10 +1,10 @@
1	1	const std = @import("std");
2	2	const builtin = @import("builtin");
3		const common = @import("common.zig");
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4	const bigIntFromFloat = @import("int_from_float.zig").bigIntFromFloat;
5	5
6	6	comptime {
7		@export(&__fixunsxfei, .{ .name = "__fixunsxfei", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__fixunsxfei, "__fixunsxfei");
8	8	}
9	9
10	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		const common = @import("./common.zig");
	1	const symbol = @import("../compiler_rt.zig").symbol;
2	2	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3	3
4	4	comptime {
5		@export(&__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage, .visibility = common.visibility });
	5	symbol(&__fixxfdi, "__fixxfdi");
6	6	}
7	7
8	8	fn __fixxfdi(a: f80) callconv(.c) i64 {

lib/compiler_rt/fixxfti.zig+4-2

...	...	@@ -1,12 +1,14 @@
1	1	const builtin = @import("builtin");
	2
2	3	const common = @import("./common.zig");
3	4	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
	5	const symbol = @import("../compiler_rt.zig").symbol;
4	6
5	7	comptime {
6	8	if (common.want_windows_v2u64_abi) {
7		@export(&__fixxfti_windows_x86_64, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__fixxfti_windows_x86_64, "__fixxfti");
8	10	} else {
9		@export(&__fixxfti, .{ .name = "__fixxfti", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__fixxfti, "__fixxfti");
10	12	}
11	13	}
12	14

lib/compiler_rt/floatdihf.zig+2-2

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

lib/compiler_rt/floatdisf.zig+4-4

...	...	@@ -1,15 +1,15 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
3	3	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
4	4
5	5	comptime {
6	6	if (common.want_aeabi) {
7		@export(&__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_l2f, "__aeabi_l2f");
8	8	} else {
9	9	if (common.want_windows_arm_abi) {
10		@export(&__floatdisf, .{ .name = "__i64tos", .linkage = common.linkage, .visibility = common.visibility });
	10	symbol(&__floatdisf, "__i64tos");
11	11	}
12		@export(&__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage, .visibility = common.visibility });
	12	symbol(&__floatdisf, "__floatdisf");
13	13	}
14	14	}
15	15

lib/compiler_rt/floatditf.zig+4-3

...	...	@@ -1,13 +1,14 @@
1	1	const common = @import("./common.zig");
2	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_ppc_abi) {
6		@export(&__floatditf, .{ .name = "__floatdikf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floatditf, "__floatdikf");
7	8	} else if (common.want_sparc_abi) {
8		@export(&_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&_Qp_xtoq, "_Qp_xtoq");
9	10	}
10		@export(&__floatditf, .{ .name = "__floatditf", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__floatditf, "__floatditf");
11	12	}
12	13
13	14	pub fn __floatditf(a: i64) callconv(.c) f128 {

lib/compiler_rt/floatdixf.zig+2-2

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

lib/compiler_rt/floateidf.zig+5-3

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

lib/compiler_rt/floateixf.zig+5-3

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

lib/compiler_rt/floatsixf.zig+2-1

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

lib/compiler_rt/floattidf.zig+3-3

...	...	@@ -1,12 +1,12 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
3	3	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__floattidf_windows_x86_64, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floattidf_windows_x86_64, "__floattidf");
8	8	} else {
9		@export(&__floattidf, .{ .name = "__floattidf", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__floattidf, "__floattidf");
10	10	}
11	11	}
12	12

lib/compiler_rt/floattisf.zig+3-3

...	...	@@ -1,12 +1,12 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
3	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__floattisf_windows_x86_64, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floattisf_windows_x86_64, "__floattisf");
8	8	} else {
9		@export(&__floattisf, .{ .name = "__floattisf", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__floattisf, "__floattisf");
10	10	}
11	11	}
12	12

lib/compiler_rt/floattitf.zig+4-4

...	...	@@ -1,14 +1,14 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
3	3	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__floattitf_windows_x86_64, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floattitf_windows_x86_64, "__floattitf");
8	8	} else {
9	9	if (common.want_ppc_abi)
10		@export(&__floattitf, .{ .name = "__floattikf", .linkage = common.linkage, .visibility = common.visibility });
11		@export(&__floattitf, .{ .name = "__floattitf", .linkage = common.linkage, .visibility = common.visibility });
	10	symbol(&__floattitf, "__floattikf");
	11	symbol(&__floattitf, "__floattitf");
12	12	}
13	13	}
14	14

lib/compiler_rt/floatundidf.zig+4-4

...	...	@@ -1,15 +1,15 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
3	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6	6	if (common.want_aeabi) {
7		@export(&__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_ul2d, "__aeabi_ul2d");
8	8	} else {
9	9	if (common.want_windows_arm_abi) {
10		@export(&__floatundidf, .{ .name = "__u64tod", .linkage = common.linkage, .visibility = common.visibility });
	10	symbol(&__floatundidf, "__u64tod");
11	11	}
12		@export(&__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage, .visibility = common.visibility });
	12	symbol(&__floatundidf, "__floatundidf");
13	13	}
14	14	}
15	15

lib/compiler_rt/floatuneitf.zig+5-3

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

lib/compiler_rt/floatunsihf.zig+2-2

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

lib/compiler_rt/floatunsisf.zig+3-2

...	...	@@ -1,11 +1,12 @@
1	1	const common = @import("./common.zig");
2	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_ui2f, "__aeabi_ui2f");
7	8	} else {
8		@export(&__floatunsisf, .{ .name = "__floatunsisf", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__floatunsisf, "__floatunsisf");
9	10	}
10	11	}
11	12

lib/compiler_rt/floatunsitf.zig+4-3

...	...	@@ -1,13 +1,14 @@
1	1	const common = @import("./common.zig");
2	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_ppc_abi) {
6		@export(&__floatunsitf, .{ .name = "__floatunsikf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floatunsitf, "__floatunsikf");
7	8	} else if (common.want_sparc_abi) {
8		@export(&_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&_Qp_uitoq, "_Qp_uitoq");
9	10	}
10		@export(&__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__floatunsitf, "__floatunsitf");
11	12	}
12	13
13	14	pub fn __floatunsitf(a: u32) callconv(.c) f128 {

lib/compiler_rt/floatuntidf.zig+3-3

...	...	@@ -1,12 +1,12 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
3	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__floatuntidf_windows_x86_64, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floatuntidf_windows_x86_64, "__floatuntidf");
8	8	} else {
9		@export(&__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__floatuntidf, "__floatuntidf");
10	10	}
11	11	}
12	12

lib/compiler_rt/floatuntihf.zig+3-3

...	...	@@ -1,12 +1,12 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
3	3	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__floatuntihf_windows_x86_64, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floatuntihf_windows_x86_64, "__floatuntihf");
8	8	} else {
9		@export(&__floatuntihf, .{ .name = "__floatuntihf", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__floatuntihf, "__floatuntihf");
10	10	}
11	11	}
12	12

lib/compiler_rt/floatuntitf.zig+4-4

...	...	@@ -1,14 +1,14 @@
1		const builtin = @import("builtin");
2	1	const common = @import("./common.zig");
3	2	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6	6	if (common.want_windows_v2u64_abi) {
7		@export(&__floatuntitf_windows_x86_64, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__floatuntitf_windows_x86_64, "__floatuntitf");
8	8	} else {
9	9	if (common.want_ppc_abi)
10		@export(&__floatuntitf, .{ .name = "__floatuntikf", .linkage = common.linkage, .visibility = common.visibility });
11		@export(&__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage, .visibility = common.visibility });
	10	symbol(&__floatuntitf, "__floatuntikf");
	11	symbol(&__floatuntitf, "__floatuntitf");
12	12	}
13	13	}
14	14

lib/compiler_rt/floor_ceil.zig+15-14

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

lib/compiler_rt/gedf2.zig+5-4

...	...	@@ -2,14 +2,15 @@
2	2	///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
3	3	const common = @import("./common.zig");
4	4	const comparef = @import("./comparef.zig");
	5	const symbol = @import("../compiler_rt.zig").symbol;
5	6
6	7	comptime {
7	8	if (common.want_aeabi) {
8		@export(&__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = common.linkage, .visibility = common.visibility });
9		@export(&__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__aeabi_dcmpge, "__aeabi_dcmpge");
	10	symbol(&__aeabi_dcmpgt, "__aeabi_dcmpgt");
10	11	} else {
11		@export(&__gedf2, .{ .name = "__gedf2", .linkage = common.linkage, .visibility = common.visibility });
12		@export(&__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage, .visibility = common.visibility });
	12	symbol(&__gedf2, "__gedf2");
	13	symbol(&__gtdf2, "__gtdf2");
13	14	}
14	15	}
15	16

lib/compiler_rt/gehf2.zig+3-3

...	...	@@ -1,11 +1,11 @@
1	1	///! The quoted behavior definitions are from
2	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	4	const comparef = @import("./comparef.zig");
5	5
6	6	comptime {
7		@export(&__gehf2, .{ .name = "__gehf2", .linkage = common.linkage, .visibility = common.visibility });
8		@export(&__gthf2, .{ .name = "__gthf2", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__gehf2, "__gehf2");
	8	symbol(&__gthf2, "__gthf2");
9	9	}
10	10
11	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		const common = @import("./common.zig");
	1	const symbol = @import("../compiler_rt.zig").symbol;
2	2	const comparef = @import("./comparef.zig");
3	3
4	4	comptime {
5		@export(&__gexf2, .{ .name = "__gexf2", .linkage = common.linkage, .visibility = common.visibility });
6		@export(&__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage, .visibility = common.visibility });
	5	symbol(&__gexf2, "__gexf2");
	6	symbol(&__gtxf2, "__gtxf2");
7	7	}
8	8
9	9	fn __gexf2(a: f80, b: f80) callconv(.c) i32 {

lib/compiler_rt/int.zig+19-16

...	...	@@ -1,34 +1,37 @@
1	1	//! Builtin functions that operate on integer types
2	2
3	3	const builtin = @import("builtin");
	4	const arch = builtin.cpu.arch;
	5
4	6	const std = @import("std");
5	7	const testing = std.testing;
6	8	const maxInt = std.math.maxInt;
7	9	const minInt = std.math.minInt;
8		const arch = builtin.cpu.arch;
	10
9	11	const common = @import("common.zig");
	12	const symbol = @import("../compiler_rt.zig").symbol;
10	13	const udivmod = @import("udivmod.zig").udivmod;
11	14	const __divti3 = @import("divti3.zig").__divti3;
12	15
13	16	comptime {
14		@export(&__divmodti4, .{ .name = "__divmodti4", .linkage = common.linkage, .visibility = common.visibility });
15		@export(&__udivmoddi4, .{ .name = "__udivmoddi4", .linkage = common.linkage, .visibility = common.visibility });
16		@export(&__divmoddi4, .{ .name = "__divmoddi4", .linkage = common.linkage, .visibility = common.visibility });
	17	symbol(&__divmodti4, "__divmodti4");
	18	symbol(&__udivmoddi4, "__udivmoddi4");
	19	symbol(&__divmoddi4, "__divmoddi4");
17	20	if (common.want_aeabi) {
18		@export(&__aeabi_idiv, .{ .name = "__aeabi_idiv", .linkage = common.linkage, .visibility = common.visibility });
19		@export(&__aeabi_uidiv, .{ .name = "__aeabi_uidiv", .linkage = common.linkage, .visibility = common.visibility });
	21	symbol(&__aeabi_idiv, "__aeabi_idiv");
	22	symbol(&__aeabi_uidiv, "__aeabi_uidiv");
20	23	} else {
21		@export(&__divsi3, .{ .name = "__divsi3", .linkage = common.linkage, .visibility = common.visibility });
22		@export(&__udivsi3, .{ .name = "__udivsi3", .linkage = common.linkage, .visibility = common.visibility });
	24	symbol(&__divsi3, "__divsi3");
	25	symbol(&__udivsi3, "__udivsi3");
23	26	}
24		@export(&__divdi3, .{ .name = "__divdi3", .linkage = common.linkage, .visibility = common.visibility });
25		@export(&__udivdi3, .{ .name = "__udivdi3", .linkage = common.linkage, .visibility = common.visibility });
26		@export(&__modsi3, .{ .name = "__modsi3", .linkage = common.linkage, .visibility = common.visibility });
27		@export(&__moddi3, .{ .name = "__moddi3", .linkage = common.linkage, .visibility = common.visibility });
28		@export(&__umodsi3, .{ .name = "__umodsi3", .linkage = common.linkage, .visibility = common.visibility });
29		@export(&__umoddi3, .{ .name = "__umoddi3", .linkage = common.linkage, .visibility = common.visibility });
30		@export(&__divmodsi4, .{ .name = "__divmodsi4", .linkage = common.linkage, .visibility = common.visibility });
31		@export(&__udivmodsi4, .{ .name = "__udivmodsi4", .linkage = common.linkage, .visibility = common.visibility });
	27	symbol(&__divdi3, "__divdi3");
	28	symbol(&__udivdi3, "__udivdi3");
	29	symbol(&__modsi3, "__modsi3");
	30	symbol(&__moddi3, "__moddi3");
	31	symbol(&__umodsi3, "__umodsi3");
	32	symbol(&__umoddi3, "__umoddi3");
	33	symbol(&__divmodsi4, "__divmodsi4");
	34	symbol(&__udivmodsi4, "__udivmodsi4");
32	35	}
33	36
34	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	5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/log.c?h=1b76ff0767d01df72f692806ee5adee13c67ef88
6	6
7	7	const std = @import("std");
8		const builtin = @import("builtin");
9	8	const math = std.math;
10	9	const expect = std.testing.expect;
11	10	const expectEqual = std.testing.expectEqual;
12		const arch = builtin.cpu.arch;
	11
13	12	const common = @import("common.zig");
	13	const symbol = @import("../compiler_rt.zig").symbol;
14	14
15	15	comptime {
16		@export(&__logh, .{ .name = "__logh", .linkage = common.linkage, .visibility = common.visibility });
17		@export(&logf, .{ .name = "logf", .linkage = common.linkage, .visibility = common.visibility });
18		@export(&log, .{ .name = "log", .linkage = common.linkage, .visibility = common.visibility });
19		@export(&__logx, .{ .name = "__logx", .linkage = common.linkage, .visibility = common.visibility });
	16	symbol(&__logh, "__logh");
	17	symbol(&logf, "logf");
	18	symbol(&log, "log");
	19	symbol(&__logx, "__logx");
20	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 });
24		@export(&logl, .{ .name = "logl", .linkage = common.linkage, .visibility = common.visibility });
	23	symbol(&logq, "logq");
	24	symbol(&logl, "logl");
25	25	}
26	26
27	27	pub fn __logh(a: f16) callconv(.c) f16 {

lib/compiler_rt/log10.zig+9-9

...	...	@@ -5,24 +5,24 @@
5	5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/log10.c
6	6
7	7	const std = @import("std");
8		const builtin = @import("builtin");
9	8	const math = std.math;
10	9	const expect = std.testing.expect;
11	10	const expectEqual = std.testing.expectEqual;
12	11	const maxInt = std.math.maxInt;
13		const arch = builtin.cpu.arch;
	12
14	13	const common = @import("common.zig");
	14	const symbol = @import("../compiler_rt.zig").symbol;
15	15
16	16	comptime {
17		@export(&__log10h, .{ .name = "__log10h", .linkage = common.linkage, .visibility = common.visibility });
18		@export(&log10f, .{ .name = "log10f", .linkage = common.linkage, .visibility = common.visibility });
19		@export(&log10, .{ .name = "log10", .linkage = common.linkage, .visibility = common.visibility });
20		@export(&__log10x, .{ .name = "__log10x", .linkage = common.linkage, .visibility = common.visibility });
	17	symbol(&__log10h, "__log10h");
	18	symbol(&log10f, "log10f");
	19	symbol(&log10, "log10");
	20	symbol(&__log10x, "__log10x");
21	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 });
25		@export(&log10l, .{ .name = "log10l", .linkage = common.linkage, .visibility = common.visibility });
	24	symbol(&log10q, "log10q");
	25	symbol(&log10l, "log10l");
26	26	}
27	27
28	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 @@
1		const common = @import("./common.zig");
2	1	const mulc3 = @import("./mulc3.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
3	3
4	4	comptime {
5	5	if (@import("builtin").zig_backend != .stage2_c) {
6		@export(&__muldc3, .{ .name = "__muldc3", .linkage = common.linkage, .visibility = common.visibility });
	6	symbol(&__muldc3, "__muldc3");
7	7	}
8	8	}
9	9

lib/compiler_rt/muldf3.zig+3-2

...	...	@@ -1,11 +1,12 @@
1	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
2	3	const mulf3 = @import("./mulf3.zig").mulf3;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_dmul, "__aeabi_dmul");
7	8	} else {
8		@export(&__muldf3, .{ .name = "__muldf3", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__muldf3, "__muldf3");
9	10	}
10	11	}
11	12

lib/compiler_rt/mulsc3.zig+2-2

...	...	@@ -1,9 +1,9 @@
1		const common = @import("./common.zig");
	1	const symbol = @import("../compiler_rt.zig").symbol;
2	2	const mulc3 = @import("./mulc3.zig");
3	3
4	4	comptime {
5	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 @@
1	1	const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
2	3	const mulc3 = @import("./mulc3.zig");
3	4
4	5	comptime {
5	6	if (@import("builtin").zig_backend != .stage2_c) {
6	7	if (common.want_ppc_abi)
7		@export(&__multc3, .{ .name = "__mulkc3", .linkage = common.linkage, .visibility = common.visibility });
8		@export(&__multc3, .{ .name = "__multc3", .linkage = common.linkage, .visibility = common.visibility });
	8	symbol(&__multc3, "__mulkc3");
	9	symbol(&__multc3, "__multc3");
9	10	}
10	11	}
11	12

lib/compiler_rt/mulvsi3.zig+4-3

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

lib/compiler_rt/negtf2.zig+3-2

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

lib/compiler_rt/parity.zig+5-8

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

lib/compiler_rt/popcount.zig+4-6

...	...	@@ -6,14 +6,12 @@
6	6	//! TAOCP: Combinational Algorithms, Bitwise Tricks And Techniques,
7	7	//! subsubsection "Working with the rightmost bits" and "Sideways addition".
8	8
9		const builtin = @import("builtin");
10		const std = @import("std");
11		const common = @import("common.zig");
	9	const symbol = @import("../compiler_rt.zig").symbol;
12	10
13	11	comptime {
14		@export(&__popcountsi2, .{ .name = "__popcountsi2", .linkage = common.linkage, .visibility = common.visibility });
15		@export(&__popcountdi2, .{ .name = "__popcountdi2", .linkage = common.linkage, .visibility = common.visibility });
16		@export(&__popcountti2, .{ .name = "__popcountti2", .linkage = common.linkage, .visibility = common.visibility });
	12	symbol(&__popcountsi2, "__popcountsi2");
	13	symbol(&__popcountdi2, "__popcountdi2");
	14	symbol(&__popcountti2, "__popcountti2");
17	15	}
18	16
19	17	pub fn __popcountsi2(a: i32) callconv(.c) i32 {

lib/compiler_rt/powiXf2.zig+7-8

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

lib/compiler_rt/sin.zig+9-10

...	...	@@ -5,27 +5,26 @@
5	5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/sin.c
6	6
7	7	const std = @import("std");
8		const builtin = @import("builtin");
9		const arch = builtin.cpu.arch;
10	8	const math = std.math;
11	9	const mem = std.mem;
12	10	const expect = std.testing.expect;
13		const common = @import("common.zig");
14	11
	12	const common = @import("common.zig");
	13	const symbol = @import("../compiler_rt.zig").symbol;
15	14	const trig = @import("trig.zig");
16	15	const rem_pio2 = @import("rem_pio2.zig").rem_pio2;
17	16	const rem_pio2f = @import("rem_pio2f.zig").rem_pio2f;
18	17
19	18	comptime {
20		@export(&__sinh, .{ .name = "__sinh", .linkage = common.linkage, .visibility = common.visibility });
21		@export(&sinf, .{ .name = "sinf", .linkage = common.linkage, .visibility = common.visibility });
22		@export(&sin, .{ .name = "sin", .linkage = common.linkage, .visibility = common.visibility });
23		@export(&__sinx, .{ .name = "__sinx", .linkage = common.linkage, .visibility = common.visibility });
	19	symbol(&__sinh, "__sinh");
	20	symbol(&sinf, "sinf");
	21	symbol(&sin, "sin");
	22	symbol(&__sinx, "__sinx");
24	23	if (common.want_ppc_abi) {
25		@export(&sinq, .{ .name = "sinf128", .linkage = common.linkage, .visibility = common.visibility });
	24	symbol(&sinq, "sinf128");
26	25	}
27		@export(&sinq, .{ .name = "sinq", .linkage = common.linkage, .visibility = common.visibility });
28		@export(&sinl, .{ .name = "sinl", .linkage = common.linkage, .visibility = common.visibility });
	26	symbol(&sinq, "sinq");
	27	symbol(&sinl, "sinl");
29	28	}
30	29
31	30	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 @@
1	1	const common = @import("./common.zig");
2	2	const addf3 = @import("./addf3.zig").addf3;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_dsub, "__aeabi_dsub");
7	8	} else {
8		@export(&__subdf3, .{ .name = "__subdf3", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__subdf3, "__subdf3");
9	10	}
10	11	}
11	12

lib/compiler_rt/subvdi3.zig+2-2

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

lib/compiler_rt/subxf3.zig+2-2

...	...	@@ -1,8 +1,8 @@
1	1	const std = @import("std");
2		const common = @import("./common.zig");
	2	const symbol = @import("../compiler_rt.zig").symbol;
3	3
4	4	comptime {
5		@export(&__subxf3, .{ .name = "__subxf3", .linkage = common.linkage, .visibility = common.visibility });
	5	symbol(&__subxf3, "__subxf3");
6	6	}
7	7
8	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
18	18	const arch = builtin.cpu.arch;
19	19	const common = @import("common.zig");
	20	const symbol = @import("../compiler_rt.zig").symbol;
20	21
21	22	comptime {
22		@export(&__tanh, .{ .name = "__tanh", .linkage = common.linkage, .visibility = common.visibility });
23		@export(&tanf, .{ .name = "tanf", .linkage = common.linkage, .visibility = common.visibility });
24		@export(&tan, .{ .name = "tan", .linkage = common.linkage, .visibility = common.visibility });
25		@export(&__tanx, .{ .name = "__tanx", .linkage = common.linkage, .visibility = common.visibility });
	23	symbol(&__tanh, "__tanh");
	24	symbol(&tanf, "tanf");
	25	symbol(&tan, "tan");
	26	symbol(&__tanx, "__tanx");
26	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		@export(&tanl, .{ .name = "tanl", .linkage = common.linkage, .visibility = common.visibility });
	30	symbol(&tanq, "tanq");
	31	symbol(&tanl, "tanl");
31	32	}
32	33
33	34	pub fn __tanh(x: f16) callconv(.c) f16 {

lib/compiler_rt/trunc.zig+11-8

...	...	@@ -4,24 +4,27 @@
4	4	//! https://git.musl-libc.org/cgit/musl/tree/src/math/truncf.c
5	5	//! https://git.musl-libc.org/cgit/musl/tree/src/math/trunc.c
6	6
7		const std = @import("std");
8	7	const builtin = @import("builtin");
9	8	const arch = builtin.cpu.arch;
	9
	10	const std = @import("std");
10	11	const math = std.math;
11	12	const mem = std.mem;
12	13	const expect = std.testing.expect;
	14
13	15	const common = @import("common.zig");
	16	const symbol = @import("../compiler_rt.zig").symbol;
14	17
15	18	comptime {
16		@export(&__trunch, .{ .name = "__trunch", .linkage = common.linkage, .visibility = common.visibility });
17		@export(&truncf, .{ .name = "truncf", .linkage = common.linkage, .visibility = common.visibility });
18		@export(&trunc, .{ .name = "trunc", .linkage = common.linkage, .visibility = common.visibility });
19		@export(&__truncx, .{ .name = "__truncx", .linkage = common.linkage, .visibility = common.visibility });
	19	symbol(&__trunch, "__trunch");
	20	symbol(&truncf, "truncf");
	21	symbol(&trunc, "trunc");
	22	symbol(&__truncx, "__truncx");
20	23	if (common.want_ppc_abi) {
21		@export(&truncq, .{ .name = "truncf128", .linkage = common.linkage, .visibility = common.visibility });
	24	symbol(&truncq, "truncf128");
22	25	}
23		@export(&truncq, .{ .name = "truncq", .linkage = common.linkage, .visibility = common.visibility });
24		@export(&truncl, .{ .name = "truncl", .linkage = common.linkage, .visibility = common.visibility });
	26	symbol(&truncq, "truncq");
	27	symbol(&truncl, "truncl");
25	28	}
26	29
27	30	pub fn __trunch(x: f16) callconv(.c) f16 {

lib/compiler_rt/truncdfhf2.zig+3-2

...	...	@@ -1,11 +1,12 @@
1	1	const common = @import("./common.zig");
2	2	const truncf = @import("./truncf.zig").truncf;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_d2h, "__aeabi_d2h");
7	8	}
8		@export(&__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__truncdfhf2, "__truncdfhf2");
9	10	}
10	11
11	12	pub fn __truncdfhf2(a: f64) callconv(.c) common.F16T(f64) {

lib/compiler_rt/trunctfhf2.zig+2-1

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

lib/compiler_rt/trunctfsf2.zig+4-3

...	...	@@ -1,13 +1,14 @@
1	1	const common = @import("./common.zig");
2	2	const truncf = @import("./truncf.zig").truncf;
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_ppc_abi) {
6		@export(&__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__trunctfsf2, "__trunckfsf2");
7	8	} else if (common.want_sparc_abi) {
8		@export(&_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&_Qp_qtos, "_Qp_qtos");
9	10	}
10		@export(&__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage, .visibility = common.visibility });
	11	symbol(&__trunctfsf2, "__trunctfsf2");
11	12	}
12	13
13	14	pub fn __trunctfsf2(a: f128) callconv(.c) f32 {

lib/compiler_rt/truncxfdf2.zig+2-2

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

lib/compiler_rt/truncxfhf2.zig+2-1

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

lib/compiler_rt/truncxfsf2.zig+2-2

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

lib/compiler_rt/udivmodei4.zig+8-6

...	...	@@ -1,18 +1,20 @@
1		const std = @import("std");
2	1	const builtin = @import("builtin");
3		const common = @import("common.zig");
	2	const endian = builtin.cpu.arch.endian();
	3
	4	const std = @import("std");
4	5	const shr = std.math.shr;
5	6	const shl = std.math.shl;
6	7
	8	const common = @import("common.zig");
	9	const symbol = @import("../compiler_rt.zig").symbol;
	10
7	11	const max_limbs = std.math.divCeil(usize, 65535, 32) catch unreachable; // max supported type is u65535
8	12
9	13	comptime {
10		@export(&__udivei4, .{ .name = "__udivei4", .linkage = common.linkage, .visibility = common.visibility });
11		@export(&__umodei4, .{ .name = "__umodei4", .linkage = common.linkage, .visibility = common.visibility });
	14	symbol(&__udivei4, "__udivei4");
	15	symbol(&__umodei4, "__umodei4");
12	16	}
13	17
14		const endian = builtin.cpu.arch.endian();
15
16	18	/// Get the value of a limb.
17	19	inline fn limb(x: []const u32, i: usize) u32 {
18	20	return if (endian == .little) x[i] else x[x.len - 1 - i];

lib/compiler_rt/unorddf2.zig+3-2

...	...	@@ -1,11 +1,12 @@
1	1	const common = @import("./common.zig");
2	2	const comparef = @import("./comparef.zig");
	3	const symbol = @import("../compiler_rt.zig").symbol;
3	4
4	5	comptime {
5	6	if (common.want_aeabi) {
6		@export(&__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = common.linkage, .visibility = common.visibility });
	7	symbol(&__aeabi_dcmpun, "__aeabi_dcmpun");
7	8	} else {
8		@export(&__unorddf2, .{ .name = "__unorddf2", .linkage = common.linkage, .visibility = common.visibility });
	9	symbol(&__unorddf2, "__unorddf2");
9	10	}
10	11	}
11	12