Commit 3d604248e6c2111ff3dc48057f07ec91fdbc6a9e | zig

author	Alex Rønne Petersen <alex@alexrp.com> 2026-06-18 10:46:19+02:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-06-19 04:25:42+02:00
log	3d604248e6c2111ff3dc48057f07ec91fdbc6a9e
tree	e6af82b7c7a97c420f4e5a27e41ce348ade77e4e
parent	84f84267c72b12d4562d53df33e3c0121c7e5cee

compiler-rt: delete workarounds for __int128 ABI on x86_64-windows

LLVM requires frontends to lower i128 to <2 x i64> in IR to get the correct
__int128 ABI on x86_64-windows; this is what Clang does. I'm guessing our LLVM
backend didn't do this in the past, which made these hacks necessary. But it
does do so now, so just get rid of this stuff.

22 files changed, 34 insertions(+), 261 deletions(-)

lib/compiler_rt.zig-4

...	...	@@ -404,10 +404,6 @@ pub const want_ppc_abi = builtin.cpu.arch.isPowerPC();
404	404
405	405	pub const want_float_exceptions = !builtin.cpu.arch.isWasm();
406	406
407		// Libcalls that involve u128 on Windows x86-64 are expected by LLVM to use the
408		// calling convention of @Vector(2, u64), rather than what's standard.
409		pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and !ofmt_c;
410
411	407	/// This governs whether to use these symbol names for f16/f32 conversions
412	408	/// rather than the standard names:
413	409	/// * __gnu_f2h_ieee

lib/compiler_rt/fixdfti.zig+1-11

...	...	@@ -3,19 +3,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__fixdfti_windows_x86_64, "__fixdfti");
8		} else {
9		symbol(&__fixdfti, "__fixdfti");
10		}
	6	symbol(&__fixdfti, "__fixdfti");
11	7	}
12	8
13	9	pub fn __fixdfti(a: f64) callconv(.c) i128 {
14	10	return intFromFloat(i128, a);
15	11	}
16
17		const v2u64 = @Vector(2, u64);
18
19		fn __fixdfti_windows_x86_64(a: f64) callconv(.c) v2u64 {
20		return @bitCast(intFromFloat(i128, a));
21		}

lib/compiler_rt/fixsfti.zig+1-11

...	...	@@ -4,19 +4,9 @@ const symbol = compiler_rt.symbol;
4	4	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__fixsfti_windows_x86_64, "__fixsfti");
9		} else {
10		symbol(&__fixsfti, "__fixsfti");
11		}
	7	symbol(&__fixsfti, "__fixsfti");
12	8	}
13	9
14	10	pub fn __fixsfti(a: f32) callconv(.c) i128 {
15	11	return intFromFloat(i128, a);
16	12	}
17
18		const v2u64 = @Vector(2, u64);
19
20		fn __fixsfti_windows_x86_64(a: f32) callconv(.c) v2u64 {
21		return @bitCast(intFromFloat(i128, a));
22		}

lib/compiler_rt/fixtfti.zig+3-13

...	...	@@ -3,21 +3,11 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__fixtfti_windows_x86_64, "__fixtfti");
8		} else {
9		if (compiler_rt.want_ppc_abi)
10		symbol(&__fixtfti, "__fixkfti");
11		symbol(&__fixtfti, "__fixtfti");
12		}
	6	if (compiler_rt.want_ppc_abi)
	7	symbol(&__fixtfti, "__fixkfti");
	8	symbol(&__fixtfti, "__fixtfti");
13	9	}
14	10
15	11	pub fn __fixtfti(a: f128) callconv(.c) i128 {
16	12	return intFromFloat(i128, a);
17	13	}
18
19		const v2u64 = @Vector(2, u64);
20
21		fn __fixtfti_windows_x86_64(a: f128) callconv(.c) v2u64 {
22		return @bitCast(intFromFloat(i128, a));
23		}

lib/compiler_rt/fixunsdfti.zig+1-11

...	...	@@ -3,19 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol;
3	3	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti");
8		} else {
9		symbol(&__fixunsdfti, "__fixunsdfti");
10		}
	6	symbol(&__fixunsdfti, "__fixunsdfti");
11	7	}
12	8
13	9	pub fn __fixunsdfti(a: f64) callconv(.c) u128 {
14	10	return intFromFloat(u128, a);
15	11	}
16
17		const v2u64 = @Vector(2, u64);
18
19		fn __fixunsdfti_windows_x86_64(a: f64) callconv(.c) v2u64 {
20		return @bitCast(intFromFloat(u128, a));
21		}

lib/compiler_rt/fixunshfti.zig+1-11

...	...	@@ -3,19 +3,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__fixunshfti_windows_x86_64, "__fixunshfti");
8		} else {
9		symbol(&__fixunshfti, "__fixunshfti");
10		}
	6	symbol(&__fixunshfti, "__fixunshfti");
11	7	}
12	8
13	9	pub fn __fixunshfti(a: f16) callconv(.c) u128 {
14	10	return intFromFloat(u128, a);
15	11	}
16
17		const v2u64 = @Vector(2, u64);
18
19		fn __fixunshfti_windows_x86_64(a: f16) callconv(.c) v2u64 {
20		return @bitCast(intFromFloat(u128, a));
21		}

lib/compiler_rt/fixunssfti.zig+1-11

...	...	@@ -4,19 +4,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
4	4	const symbol = @import("../compiler_rt.zig").symbol;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__fixunssfti_windows_x86_64, "__fixunssfti");
9		} else {
10		symbol(&__fixunssfti, "__fixunssfti");
11		}
	7	symbol(&__fixunssfti, "__fixunssfti");
12	8	}
13	9
14	10	pub fn __fixunssfti(a: f32) callconv(.c) u128 {
15	11	return intFromFloat(u128, a);
16	12	}
17
18		const v2u64 = @Vector(2, u64);
19
20		fn __fixunssfti_windows_x86_64(a: f32) callconv(.c) v2u64 {
21		return @bitCast(intFromFloat(u128, a));
22		}

lib/compiler_rt/fixunstfti.zig+3-13

...	...	@@ -4,21 +4,11 @@ const symbol = compiler_rt.symbol;
4	4	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__fixunstfti_windows_x86_64, "__fixunstfti");
9		} else {
10		if (compiler_rt.want_ppc_abi)
11		symbol(&__fixunstfti, "__fixunskfti");
12		symbol(&__fixunstfti, "__fixunstfti");
13		}
	7	if (compiler_rt.want_ppc_abi)
	8	symbol(&__fixunstfti, "__fixunskfti");
	9	symbol(&__fixunstfti, "__fixunstfti");
14	10	}
15	11
16	12	pub fn __fixunstfti(a: f128) callconv(.c) u128 {
17	13	return intFromFloat(u128, a);
18	14	}
19
20		const v2u64 = @Vector(2, u64);
21
22		fn __fixunstfti_windows_x86_64(a: f128) callconv(.c) v2u64 {
23		return @bitCast(intFromFloat(u128, a));
24		}

lib/compiler_rt/fixunsxfti.zig+1-11

...	...	@@ -4,19 +4,9 @@ const symbol = compiler_rt.symbol;
4	4	const intFromFloat = @import("./int_from_float.zig").intFromFloat;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__fixunsxfti_windows_x86_64, "__fixunsxfti");
9		} else {
10		symbol(&__fixunsxfti, "__fixunsxfti");
11		}
	7	symbol(&__fixunsxfti, "__fixunsxfti");
12	8	}
13	9
14	10	pub fn __fixunsxfti(a: f80) callconv(.c) u128 {
15	11	return intFromFloat(u128, a);
16	12	}
17
18		const v2u64 = @Vector(2, u64);
19
20		fn __fixunsxfti_windows_x86_64(a: f80) callconv(.c) v2u64 {
21		return @bitCast(intFromFloat(u128, a));
22		}

lib/compiler_rt/floattidf.zig+1-9

...	...	@@ -3,17 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol;
3	3	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__floattidf_windows_x86_64, "__floattidf");
8		} else {
9		symbol(&__floattidf, "__floattidf");
10		}
	6	symbol(&__floattidf, "__floattidf");
11	7	}
12	8
13	9	pub fn __floattidf(a: i128) callconv(.c) f64 {
14	10	return floatFromInt(f64, a);
15	11	}
16
17		fn __floattidf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f64 {
18		return floatFromInt(f64, @as(i128, @bitCast(a)));
19		}

lib/compiler_rt/floattihf.zig+1-9

...	...	@@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol;
4	4	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__floattihf_windows_x86_64, "__floattihf");
9		} else {
10		symbol(&__floattihf, "__floattihf");
11		}
	7	symbol(&__floattihf, "__floattihf");
12	8	}
13	9
14	10	pub fn __floattihf(a: i128) callconv(.c) f16 {
15	11	return floatFromInt(f16, a);
16	12	}
17
18		fn __floattihf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f16 {
19		return floatFromInt(f16, @as(i128, @bitCast(a)));
20		}

lib/compiler_rt/floattisf.zig+1-9

...	...	@@ -3,17 +3,9 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__floattisf_windows_x86_64, "__floattisf");
8		} else {
9		symbol(&__floattisf, "__floattisf");
10		}
	6	symbol(&__floattisf, "__floattisf");
11	7	}
12	8
13	9	pub fn __floattisf(a: i128) callconv(.c) f32 {
14	10	return floatFromInt(f32, a);
15	11	}
16
17		fn __floattisf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f32 {
18		return floatFromInt(f32, @as(i128, @bitCast(a)));
19		}

lib/compiler_rt/floattitf.zig+3-11

...	...	@@ -3,19 +3,11 @@ const symbol = @import("../compiler_rt.zig").symbol;
3	3	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__floattitf_windows_x86_64, "__floattitf");
8		} else {
9		if (compiler_rt.want_ppc_abi)
10		symbol(&__floattitf, "__floattikf");
11		symbol(&__floattitf, "__floattitf");
12		}
	6	if (compiler_rt.want_ppc_abi)
	7	symbol(&__floattitf, "__floattikf");
	8	symbol(&__floattitf, "__floattitf");
13	9	}
14	10
15	11	pub fn __floattitf(a: i128) callconv(.c) f128 {
16	12	return floatFromInt(f128, a);
17	13	}
18
19		fn __floattitf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f128 {
20		return floatFromInt(f128, @as(i128, @bitCast(a)));
21		}

lib/compiler_rt/floattixf.zig+1-9

...	...	@@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol;
4	4	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__floattixf_windows_x86_64, "__floattixf");
9		} else {
10		symbol(&__floattixf, "__floattixf");
11		}
	7	symbol(&__floattixf, "__floattixf");
12	8	}
13	9
14	10	pub fn __floattixf(a: i128) callconv(.c) f80 {
15	11	return floatFromInt(f80, a);
16	12	}
17
18		fn __floattixf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f80 {
19		return floatFromInt(f80, @as(i128, @bitCast(a)));
20		}

lib/compiler_rt/floatuntidf.zig+1-9

...	...	@@ -3,17 +3,9 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__floatuntidf_windows_x86_64, "__floatuntidf");
8		} else {
9		symbol(&__floatuntidf, "__floatuntidf");
10		}
	6	symbol(&__floatuntidf, "__floatuntidf");
11	7	}
12	8
13	9	pub fn __floatuntidf(a: u128) callconv(.c) f64 {
14	10	return floatFromInt(f64, a);
15	11	}
16
17		fn __floatuntidf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f64 {
18		return floatFromInt(f64, @as(u128, @bitCast(a)));
19		}

lib/compiler_rt/floatuntihf.zig+1-9

...	...	@@ -3,17 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol;
3	3	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__floatuntihf_windows_x86_64, "__floatuntihf");
8		} else {
9		symbol(&__floatuntihf, "__floatuntihf");
10		}
	6	symbol(&__floatuntihf, "__floatuntihf");
11	7	}
12	8
13	9	pub fn __floatuntihf(a: u128) callconv(.c) f16 {
14	10	return floatFromInt(f16, a);
15	11	}
16
17		fn __floatuntihf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f16 {
18		return floatFromInt(f16, @as(u128, @bitCast(a)));
19		}

lib/compiler_rt/floatuntisf.zig+1-9

...	...	@@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol;
4	4	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__floatuntisf_windows_x86_64, "__floatuntisf");
9		} else {
10		symbol(&__floatuntisf, "__floatuntisf");
11		}
	7	symbol(&__floatuntisf, "__floatuntisf");
12	8	}
13	9
14	10	pub fn __floatuntisf(a: u128) callconv(.c) f32 {
15	11	return floatFromInt(f32, a);
16	12	}
17
18		fn __floatuntisf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f32 {
19		return floatFromInt(f32, @as(u128, @bitCast(a)));
20		}

lib/compiler_rt/floatuntitf.zig+3-11

...	...	@@ -3,19 +3,11 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3	3	const symbol = @import("../compiler_rt.zig").symbol;
4	4
5	5	comptime {
6		if (compiler_rt.want_windows_v2u64_abi) {
7		symbol(&__floatuntitf_windows_x86_64, "__floatuntitf");
8		} else {
9		if (compiler_rt.want_ppc_abi)
10		symbol(&__floatuntitf, "__floatuntikf");
11		symbol(&__floatuntitf, "__floatuntitf");
12		}
	6	if (compiler_rt.want_ppc_abi)
	7	symbol(&__floatuntitf, "__floatuntikf");
	8	symbol(&__floatuntitf, "__floatuntitf");
13	9	}
14	10
15	11	pub fn __floatuntitf(a: u128) callconv(.c) f128 {
16	12	return floatFromInt(f128, a);
17	13	}
18
19		fn __floatuntitf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f128 {
20		return floatFromInt(f128, @as(u128, @bitCast(a)));
21		}

lib/compiler_rt/floatuntixf.zig+1-9

...	...	@@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol;
4	4	const floatFromInt = @import("./float_from_int.zig").floatFromInt;
5	5
6	6	comptime {
7		if (compiler_rt.want_windows_v2u64_abi) {
8		symbol(&__floatuntixf_windows_x86_64, "__floatuntixf");
9		} else {
10		symbol(&__floatuntixf, "__floatuntixf");
11		}
	7	symbol(&__floatuntixf, "__floatuntixf");
12	8	}
13	9
14	10	pub fn __floatuntixf(a: u128) callconv(.c) f80 {
15	11	return floatFromInt(f80, a);
16	12	}
17
18		fn __floatuntixf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f80 {
19		return floatFromInt(f80, @as(u128, @bitCast(a)));
20		}

lib/compiler_rt/int_from_float.zig+2-22

...	...	@@ -6,32 +6,16 @@ const compiler_rt = @import("../compiler_rt.zig");
6	6	const symbol = compiler_rt.symbol;
7	7
8	8	comptime {
9		if (compiler_rt.want_windows_v2u64_abi) {
10		symbol(&__fixxfti_windows_x86_64, "__fixxfti");
11		} else {
12		symbol(&__fixxfti, "__fixxfti");
13		}
14
	9	symbol(&__fixxfti, "__fixxfti");
15	10	symbol(&__fixhfsi, "__fixhfsi");
16	11	symbol(&__fixhfdi, "__fixhfdi");
17
18		if (compiler_rt.want_windows_v2u64_abi) {
19		symbol(&__fixhfti_windows_x86_64, "__fixhfti");
20		} else {
21		symbol(&__fixhfti, "__fixhfti");
22		}
	12	symbol(&__fixhfti, "__fixhfti");
23	13	}
24	14
25		const v2u64 = @Vector(2, u64);
26
27	15	pub fn __fixhfti(a: f16) callconv(.c) i128 {
28	16	return intFromFloat(i128, a);
29	17	}
30	18
31		fn __fixhfti_windows_x86_64(a: f16) callconv(.c) v2u64 {
32		return @bitCast(intFromFloat(i128, a));
33		}
34
35	19	fn __fixhfdi(a: f16) callconv(.c) i64 {
36	20	return intFromFloat(i64, a);
37	21	}
...	...	@@ -44,10 +28,6 @@ pub fn __fixxfti(a: f80) callconv(.c) i128 {
44	28	return intFromFloat(i128, a);
45	29	}
46	30
47		fn __fixxfti_windows_x86_64(a: f80) callconv(.c) v2u64 {
48		return @bitCast(intFromFloat(i128, a));
49		}
50
51	31	pub inline fn intFromFloat(comptime I: type, a: anytype) I {
52	32	const F = @TypeOf(a);
53	33	const float_bits = @typeInfo(F).float.bits;

lib/compiler_rt/mulXi3.zig+1-11

...	...	@@ -12,11 +12,7 @@ comptime {
12	12	} else {
13	13	symbol(&__muldi3, "__muldi3");
14	14	}
15		if (compiler_rt.want_windows_v2u64_abi) {
16		symbol(&__multi3_windows_x86_64, "__multi3");
17		} else {
18		symbol(&__multi3, "__multi3");
19		}
	15	symbol(&__multi3, "__multi3");
20	16	}
21	17
22	18	pub fn __mulsi3(a: i32, b: i32) callconv(.c) i32 {
...	...	@@ -89,12 +85,6 @@ pub fn __multi3(a: i128, b: i128) callconv(.c) i128 {
89	85	return mulX(i128, a, b);
90	86	}
91	87
92		const v2u64 = @Vector(2, u64);
93
94		fn __multi3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
95		return @bitCast(mulX(i128, @as(i128, @bitCast(a)), @as(i128, @bitCast(b))));
96		}
97
98	88	test {
99	89	_ = @import("mulXi3_test.zig");
100	90	}

lib/compiler_rt/udivmod.zig+5-38

...	...	@@ -8,40 +8,21 @@ const symbol = compiler_rt.symbol;
8	8	const HalveInt = compiler_rt.HalveInt;
9	9
10	10	comptime {
11		if (compiler_rt.want_windows_v2u64_abi) {
12		symbol(&__umodti3_windows_x86_64, "__umodti3");
13		symbol(&__modti3_windows_x86_64, "__modti3");
14		symbol(&__udivti3_windows_x86_64, "__udivti3");
15		symbol(&__divti3_windows_x86_64, "__divti3");
16		symbol(&__udivmodti4_windows_x86_64, "__udivmodti4");
17		} else {
18		symbol(&__umodti3, "__umodti3");
19		symbol(&__modti3, "__modti3");
20		symbol(&__udivti3, "__udivti3");
21		symbol(&__divti3, "__divti3");
22		symbol(&__udivmodti4, "__udivmodti4");
23		}
	11	symbol(&__umodti3, "__umodti3");
	12	symbol(&__modti3, "__modti3");
	13	symbol(&__udivti3, "__udivti3");
	14	symbol(&__divti3, "__divti3");
	15	symbol(&__udivmodti4, "__udivmodti4");
24	16	}
25	17
26		const v128 = @Vector(2, u64);
27		const v2u64 = @Vector(2, u64);
28
29	18	pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.c) u128 {
30	19	return udivmod(u128, a, b, maybe_rem);
31	20	}
32	21
33		fn __udivmodti4_windows_x86_64(a: v2u64, b: v2u64, maybe_rem: ?*u128) callconv(.c) v2u64 {
34		return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), maybe_rem));
35		}
36
37	22	pub fn __divti3(a: i128, b: i128) callconv(.c) i128 {
38	23	return div(a, b);
39	24	}
40	25
41		fn __divti3_windows_x86_64(a: v128, b: v128) callconv(.c) v128 {
42		return @bitCast(div(@bitCast(a), @bitCast(b)));
43		}
44
45	26	inline fn div(a: i128, b: i128) i128 {
46	27	const s_a = a >> (128 - 1);
47	28	const s_b = b >> (128 - 1);
...	...	@@ -58,18 +39,10 @@ pub fn __udivti3(a: u128, b: u128) callconv(.c) u128 {
58	39	return udivmod(u128, a, b, null);
59	40	}
60	41
61		fn __udivti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
62		return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), null));
63		}
64
65	42	pub fn __modti3(a: i128, b: i128) callconv(.c) i128 {
66	43	return mod(a, b);
67	44	}
68	45
69		fn __modti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
70		return @bitCast(mod(@as(i128, @bitCast(a)), @as(i128, @bitCast(b))));
71		}
72
73	46	inline fn mod(a: i128, b: i128) i128 {
74	47	const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 0
75	48	const s_b = b >> (128 - 1); // s = b < 0 ? -1 : 0
...	...	@@ -88,12 +61,6 @@ pub fn __umodti3(a: u128, b: u128) callconv(.c) u128 {
88	61	return r;
89	62	}
90	63
91		fn __umodti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
92		var r: u128 = undefined;
93		_ = udivmod(u128, @bitCast(a), @bitCast(b), &r);
94		return @bitCast(r);
95		}
96
97	64	const lo = switch (builtin.cpu.arch.endian()) {
98	65	.big => 1,
99	66	.little => 0,