authorgravatar for alex@alexrp.comAlex Rønne Petersen <alex@alexrp.com> 2026-06-18 10:46:19+02:00
committergravatar for alex@alexrp.comAlex Rønne Petersen <alex@alexrp.com> 2026-06-19 04:25:42+02:00
log3d604248e6c2111ff3dc48057f07ec91fdbc6a9e
treee6af82b7c7a97c420f4e5a27e41ce348ade77e4e
parent84f84267c72b12d4562d53df33e3c0121c7e5cee

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,10 +404,6 @@ pub const want_ppc_abi = builtin.cpu.arch.isPowerPC();
404404
405pub const want_float_exceptions = !builtin.cpu.arch.isWasm();405pub const want_float_exceptions = !builtin.cpu.arch.isWasm();
406406
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.
409pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and !ofmt_c;
410
411/// This governs whether to use these symbol names for f16/f32 conversions407/// This governs whether to use these symbol names for f16/f32 conversions
412/// rather than the standard names:408/// rather than the standard names:
413/// * __gnu_f2h_ieee409/// * __gnu_f2h_ieee
lib/compiler_rt/fixdfti.zig+1-11
...@@ -3,19 +3,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;...@@ -3,19 +3,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3const symbol = @import("../compiler_rt.zig").symbol;3const symbol = @import("../compiler_rt.zig").symbol;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 symbol(&__fixdfti, "__fixdfti");
7 symbol(&__fixdfti_windows_x86_64, "__fixdfti");
8 } else {
9 symbol(&__fixdfti, "__fixdfti");
10 }
11}7}
128
13pub fn __fixdfti(a: f64) callconv(.c) i128 {9pub fn __fixdfti(a: f64) callconv(.c) i128 {
14 return intFromFloat(i128, a);10 return intFromFloat(i128, a);
15}11}
16
17const v2u64 = @Vector(2, u64);
18
19fn __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,19 +4,9 @@ const symbol = compiler_rt.symbol;
4const intFromFloat = @import("./int_from_float.zig").intFromFloat;4const intFromFloat = @import("./int_from_float.zig").intFromFloat;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 symbol(&__fixsfti, "__fixsfti");
8 symbol(&__fixsfti_windows_x86_64, "__fixsfti");
9 } else {
10 symbol(&__fixsfti, "__fixsfti");
11 }
12}8}
139
14pub fn __fixsfti(a: f32) callconv(.c) i128 {10pub fn __fixsfti(a: f32) callconv(.c) i128 {
15 return intFromFloat(i128, a);11 return intFromFloat(i128, a);
16}12}
17
18const v2u64 = @Vector(2, u64);
19
20fn __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,21 +3,11 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3const symbol = @import("../compiler_rt.zig").symbol;3const symbol = @import("../compiler_rt.zig").symbol;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 if (compiler_rt.want_ppc_abi)
7 symbol(&__fixtfti_windows_x86_64, "__fixtfti");7 symbol(&__fixtfti, "__fixkfti");
8 } else {8 symbol(&__fixtfti, "__fixtfti");
9 if (compiler_rt.want_ppc_abi)
10 symbol(&__fixtfti, "__fixkfti");
11 symbol(&__fixtfti, "__fixtfti");
12 }
13}9}
1410
15pub fn __fixtfti(a: f128) callconv(.c) i128 {11pub fn __fixtfti(a: f128) callconv(.c) i128 {
16 return intFromFloat(i128, a);12 return intFromFloat(i128, a);
17}13}
18
19const v2u64 = @Vector(2, u64);
20
21fn __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,19 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol;
3const intFromFloat = @import("./int_from_float.zig").intFromFloat;3const intFromFloat = @import("./int_from_float.zig").intFromFloat;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 symbol(&__fixunsdfti, "__fixunsdfti");
7 symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti");
8 } else {
9 symbol(&__fixunsdfti, "__fixunsdfti");
10 }
11}7}
128
13pub fn __fixunsdfti(a: f64) callconv(.c) u128 {9pub fn __fixunsdfti(a: f64) callconv(.c) u128 {
14 return intFromFloat(u128, a);10 return intFromFloat(u128, a);
15}11}
16
17const v2u64 = @Vector(2, u64);
18
19fn __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,19 +3,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
3const symbol = @import("../compiler_rt.zig").symbol;3const symbol = @import("../compiler_rt.zig").symbol;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 symbol(&__fixunshfti, "__fixunshfti");
7 symbol(&__fixunshfti_windows_x86_64, "__fixunshfti");
8 } else {
9 symbol(&__fixunshfti, "__fixunshfti");
10 }
11}7}
128
13pub fn __fixunshfti(a: f16) callconv(.c) u128 {9pub fn __fixunshfti(a: f16) callconv(.c) u128 {
14 return intFromFloat(u128, a);10 return intFromFloat(u128, a);
15}11}
16
17const v2u64 = @Vector(2, u64);
18
19fn __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,19 +4,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat;
4const symbol = @import("../compiler_rt.zig").symbol;4const symbol = @import("../compiler_rt.zig").symbol;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 symbol(&__fixunssfti, "__fixunssfti");
8 symbol(&__fixunssfti_windows_x86_64, "__fixunssfti");
9 } else {
10 symbol(&__fixunssfti, "__fixunssfti");
11 }
12}8}
139
14pub fn __fixunssfti(a: f32) callconv(.c) u128 {10pub fn __fixunssfti(a: f32) callconv(.c) u128 {
15 return intFromFloat(u128, a);11 return intFromFloat(u128, a);
16}12}
17
18const v2u64 = @Vector(2, u64);
19
20fn __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,21 +4,11 @@ const symbol = compiler_rt.symbol;
4const intFromFloat = @import("./int_from_float.zig").intFromFloat;4const intFromFloat = @import("./int_from_float.zig").intFromFloat;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 if (compiler_rt.want_ppc_abi)
8 symbol(&__fixunstfti_windows_x86_64, "__fixunstfti");8 symbol(&__fixunstfti, "__fixunskfti");
9 } else {9 symbol(&__fixunstfti, "__fixunstfti");
10 if (compiler_rt.want_ppc_abi)
11 symbol(&__fixunstfti, "__fixunskfti");
12 symbol(&__fixunstfti, "__fixunstfti");
13 }
14}10}
1511
16pub fn __fixunstfti(a: f128) callconv(.c) u128 {12pub fn __fixunstfti(a: f128) callconv(.c) u128 {
17 return intFromFloat(u128, a);13 return intFromFloat(u128, a);
18}14}
19
20const v2u64 = @Vector(2, u64);
21
22fn __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,19 +4,9 @@ const symbol = compiler_rt.symbol;
4const intFromFloat = @import("./int_from_float.zig").intFromFloat;4const intFromFloat = @import("./int_from_float.zig").intFromFloat;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 symbol(&__fixunsxfti, "__fixunsxfti");
8 symbol(&__fixunsxfti_windows_x86_64, "__fixunsxfti");
9 } else {
10 symbol(&__fixunsxfti, "__fixunsxfti");
11 }
12}8}
139
14pub fn __fixunsxfti(a: f80) callconv(.c) u128 {10pub fn __fixunsxfti(a: f80) callconv(.c) u128 {
15 return intFromFloat(u128, a);11 return intFromFloat(u128, a);
16}12}
17
18const v2u64 = @Vector(2, u64);
19
20fn __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,17 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol;
3const floatFromInt = @import("./float_from_int.zig").floatFromInt;3const floatFromInt = @import("./float_from_int.zig").floatFromInt;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 symbol(&__floattidf, "__floattidf");
7 symbol(&__floattidf_windows_x86_64, "__floattidf");
8 } else {
9 symbol(&__floattidf, "__floattidf");
10 }
11}7}
128
13pub fn __floattidf(a: i128) callconv(.c) f64 {9pub fn __floattidf(a: i128) callconv(.c) f64 {
14 return floatFromInt(f64, a);10 return floatFromInt(f64, a);
15}11}
16
17fn __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,17 +4,9 @@ const symbol = compiler_rt.symbol;
4const floatFromInt = @import("./float_from_int.zig").floatFromInt;4const floatFromInt = @import("./float_from_int.zig").floatFromInt;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 symbol(&__floattihf, "__floattihf");
8 symbol(&__floattihf_windows_x86_64, "__floattihf");
9 } else {
10 symbol(&__floattihf, "__floattihf");
11 }
12}8}
139
14pub fn __floattihf(a: i128) callconv(.c) f16 {10pub fn __floattihf(a: i128) callconv(.c) f16 {
15 return floatFromInt(f16, a);11 return floatFromInt(f16, a);
16}12}
17
18fn __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,17 +3,9 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3const symbol = @import("../compiler_rt.zig").symbol;3const symbol = @import("../compiler_rt.zig").symbol;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 symbol(&__floattisf, "__floattisf");
7 symbol(&__floattisf_windows_x86_64, "__floattisf");
8 } else {
9 symbol(&__floattisf, "__floattisf");
10 }
11}7}
128
13pub fn __floattisf(a: i128) callconv(.c) f32 {9pub fn __floattisf(a: i128) callconv(.c) f32 {
14 return floatFromInt(f32, a);10 return floatFromInt(f32, a);
15}11}
16
17fn __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,19 +3,11 @@ const symbol = @import("../compiler_rt.zig").symbol;
3const floatFromInt = @import("./float_from_int.zig").floatFromInt;3const floatFromInt = @import("./float_from_int.zig").floatFromInt;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 if (compiler_rt.want_ppc_abi)
7 symbol(&__floattitf_windows_x86_64, "__floattitf");7 symbol(&__floattitf, "__floattikf");
8 } else {8 symbol(&__floattitf, "__floattitf");
9 if (compiler_rt.want_ppc_abi)
10 symbol(&__floattitf, "__floattikf");
11 symbol(&__floattitf, "__floattitf");
12 }
13}9}
1410
15pub fn __floattitf(a: i128) callconv(.c) f128 {11pub fn __floattitf(a: i128) callconv(.c) f128 {
16 return floatFromInt(f128, a);12 return floatFromInt(f128, a);
17}13}
18
19fn __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,17 +4,9 @@ const symbol = compiler_rt.symbol;
4const floatFromInt = @import("./float_from_int.zig").floatFromInt;4const floatFromInt = @import("./float_from_int.zig").floatFromInt;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 symbol(&__floattixf, "__floattixf");
8 symbol(&__floattixf_windows_x86_64, "__floattixf");
9 } else {
10 symbol(&__floattixf, "__floattixf");
11 }
12}8}
139
14pub fn __floattixf(a: i128) callconv(.c) f80 {10pub fn __floattixf(a: i128) callconv(.c) f80 {
15 return floatFromInt(f80, a);11 return floatFromInt(f80, a);
16}12}
17
18fn __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,17 +3,9 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3const symbol = @import("../compiler_rt.zig").symbol;3const symbol = @import("../compiler_rt.zig").symbol;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 symbol(&__floatuntidf, "__floatuntidf");
7 symbol(&__floatuntidf_windows_x86_64, "__floatuntidf");
8 } else {
9 symbol(&__floatuntidf, "__floatuntidf");
10 }
11}7}
128
13pub fn __floatuntidf(a: u128) callconv(.c) f64 {9pub fn __floatuntidf(a: u128) callconv(.c) f64 {
14 return floatFromInt(f64, a);10 return floatFromInt(f64, a);
15}11}
16
17fn __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,17 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol;
3const floatFromInt = @import("./float_from_int.zig").floatFromInt;3const floatFromInt = @import("./float_from_int.zig").floatFromInt;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 symbol(&__floatuntihf, "__floatuntihf");
7 symbol(&__floatuntihf_windows_x86_64, "__floatuntihf");
8 } else {
9 symbol(&__floatuntihf, "__floatuntihf");
10 }
11}7}
128
13pub fn __floatuntihf(a: u128) callconv(.c) f16 {9pub fn __floatuntihf(a: u128) callconv(.c) f16 {
14 return floatFromInt(f16, a);10 return floatFromInt(f16, a);
15}11}
16
17fn __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,17 +4,9 @@ const symbol = compiler_rt.symbol;
4const floatFromInt = @import("./float_from_int.zig").floatFromInt;4const floatFromInt = @import("./float_from_int.zig").floatFromInt;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 symbol(&__floatuntisf, "__floatuntisf");
8 symbol(&__floatuntisf_windows_x86_64, "__floatuntisf");
9 } else {
10 symbol(&__floatuntisf, "__floatuntisf");
11 }
12}8}
139
14pub fn __floatuntisf(a: u128) callconv(.c) f32 {10pub fn __floatuntisf(a: u128) callconv(.c) f32 {
15 return floatFromInt(f32, a);11 return floatFromInt(f32, a);
16}12}
17
18fn __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,19 +3,11 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt;
3const symbol = @import("../compiler_rt.zig").symbol;3const symbol = @import("../compiler_rt.zig").symbol;
44
5comptime {5comptime {
6 if (compiler_rt.want_windows_v2u64_abi) {6 if (compiler_rt.want_ppc_abi)
7 symbol(&__floatuntitf_windows_x86_64, "__floatuntitf");7 symbol(&__floatuntitf, "__floatuntikf");
8 } else {8 symbol(&__floatuntitf, "__floatuntitf");
9 if (compiler_rt.want_ppc_abi)
10 symbol(&__floatuntitf, "__floatuntikf");
11 symbol(&__floatuntitf, "__floatuntitf");
12 }
13}9}
1410
15pub fn __floatuntitf(a: u128) callconv(.c) f128 {11pub fn __floatuntitf(a: u128) callconv(.c) f128 {
16 return floatFromInt(f128, a);12 return floatFromInt(f128, a);
17}13}
18
19fn __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,17 +4,9 @@ const symbol = compiler_rt.symbol;
4const floatFromInt = @import("./float_from_int.zig").floatFromInt;4const floatFromInt = @import("./float_from_int.zig").floatFromInt;
55
6comptime {6comptime {
7 if (compiler_rt.want_windows_v2u64_abi) {7 symbol(&__floatuntixf, "__floatuntixf");
8 symbol(&__floatuntixf_windows_x86_64, "__floatuntixf");
9 } else {
10 symbol(&__floatuntixf, "__floatuntixf");
11 }
12}8}
139
14pub fn __floatuntixf(a: u128) callconv(.c) f80 {10pub fn __floatuntixf(a: u128) callconv(.c) f80 {
15 return floatFromInt(f80, a);11 return floatFromInt(f80, a);
16}12}
17
18fn __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,32 +6,16 @@ const compiler_rt = @import("../compiler_rt.zig");
6const symbol = compiler_rt.symbol;6const symbol = compiler_rt.symbol;
77
8comptime {8comptime {
9 if (compiler_rt.want_windows_v2u64_abi) {9 symbol(&__fixxfti, "__fixxfti");
10 symbol(&__fixxfti_windows_x86_64, "__fixxfti");
11 } else {
12 symbol(&__fixxfti, "__fixxfti");
13 }
14
15 symbol(&__fixhfsi, "__fixhfsi");10 symbol(&__fixhfsi, "__fixhfsi");
16 symbol(&__fixhfdi, "__fixhfdi");11 symbol(&__fixhfdi, "__fixhfdi");
1712 symbol(&__fixhfti, "__fixhfti");
18 if (compiler_rt.want_windows_v2u64_abi) {
19 symbol(&__fixhfti_windows_x86_64, "__fixhfti");
20 } else {
21 symbol(&__fixhfti, "__fixhfti");
22 }
23}13}
2414
25const v2u64 = @Vector(2, u64);
26
27pub fn __fixhfti(a: f16) callconv(.c) i128 {15pub fn __fixhfti(a: f16) callconv(.c) i128 {
28 return intFromFloat(i128, a);16 return intFromFloat(i128, a);
29}17}
3018
31fn __fixhfti_windows_x86_64(a: f16) callconv(.c) v2u64 {
32 return @bitCast(intFromFloat(i128, a));
33}
34
35fn __fixhfdi(a: f16) callconv(.c) i64 {19fn __fixhfdi(a: f16) callconv(.c) i64 {
36 return intFromFloat(i64, a);20 return intFromFloat(i64, a);
37}21}
...@@ -44,10 +28,6 @@ pub fn __fixxfti(a: f80) callconv(.c) i128 {...@@ -44,10 +28,6 @@ pub fn __fixxfti(a: f80) callconv(.c) i128 {
44 return intFromFloat(i128, a);28 return intFromFloat(i128, a);
45}29}
4630
47fn __fixxfti_windows_x86_64(a: f80) callconv(.c) v2u64 {
48 return @bitCast(intFromFloat(i128, a));
49}
50
51pub inline fn intFromFloat(comptime I: type, a: anytype) I {31pub inline fn intFromFloat(comptime I: type, a: anytype) I {
52 const F = @TypeOf(a);32 const F = @TypeOf(a);
53 const float_bits = @typeInfo(F).float.bits;33 const float_bits = @typeInfo(F).float.bits;
lib/compiler_rt/mulXi3.zig+1-11
...@@ -12,11 +12,7 @@ comptime {...@@ -12,11 +12,7 @@ comptime {
12 } else {12 } else {
13 symbol(&__muldi3, "__muldi3");13 symbol(&__muldi3, "__muldi3");
14 }14 }
15 if (compiler_rt.want_windows_v2u64_abi) {15 symbol(&__multi3, "__multi3");
16 symbol(&__multi3_windows_x86_64, "__multi3");
17 } else {
18 symbol(&__multi3, "__multi3");
19 }
20}16}
2117
22pub fn __mulsi3(a: i32, b: i32) callconv(.c) i32 {18pub fn __mulsi3(a: i32, b: i32) callconv(.c) i32 {
...@@ -89,12 +85,6 @@ pub fn __multi3(a: i128, b: i128) callconv(.c) i128 {...@@ -89,12 +85,6 @@ pub fn __multi3(a: i128, b: i128) callconv(.c) i128 {
89 return mulX(i128, a, b);85 return mulX(i128, a, b);
90}86}
9187
92const v2u64 = @Vector(2, u64);
93
94fn __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
98test {88test {
99 _ = @import("mulXi3_test.zig");89 _ = @import("mulXi3_test.zig");
100}90}
lib/compiler_rt/udivmod.zig+5-38
...@@ -8,40 +8,21 @@ const symbol = compiler_rt.symbol;...@@ -8,40 +8,21 @@ const symbol = compiler_rt.symbol;
8const HalveInt = compiler_rt.HalveInt;8const HalveInt = compiler_rt.HalveInt;
99
10comptime {10comptime {
11 if (compiler_rt.want_windows_v2u64_abi) {11 symbol(&__umodti3, "__umodti3");
12 symbol(&__umodti3_windows_x86_64, "__umodti3");12 symbol(&__modti3, "__modti3");
13 symbol(&__modti3_windows_x86_64, "__modti3");13 symbol(&__udivti3, "__udivti3");
14 symbol(&__udivti3_windows_x86_64, "__udivti3");14 symbol(&__divti3, "__divti3");
15 symbol(&__divti3_windows_x86_64, "__divti3");15 symbol(&__udivmodti4, "__udivmodti4");
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 }
24}16}
2517
26const v128 = @Vector(2, u64);
27const v2u64 = @Vector(2, u64);
28
29pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.c) u128 {18pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.c) u128 {
30 return udivmod(u128, a, b, maybe_rem);19 return udivmod(u128, a, b, maybe_rem);
31}20}
3221
33fn __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
37pub fn __divti3(a: i128, b: i128) callconv(.c) i128 {22pub fn __divti3(a: i128, b: i128) callconv(.c) i128 {
38 return div(a, b);23 return div(a, b);
39}24}
4025
41fn __divti3_windows_x86_64(a: v128, b: v128) callconv(.c) v128 {
42 return @bitCast(div(@bitCast(a), @bitCast(b)));
43}
44
45inline fn div(a: i128, b: i128) i128 {26inline fn div(a: i128, b: i128) i128 {
46 const s_a = a >> (128 - 1);27 const s_a = a >> (128 - 1);
47 const s_b = b >> (128 - 1);28 const s_b = b >> (128 - 1);
...@@ -58,18 +39,10 @@ pub fn __udivti3(a: u128, b: u128) callconv(.c) u128 {...@@ -58,18 +39,10 @@ pub fn __udivti3(a: u128, b: u128) callconv(.c) u128 {
58 return udivmod(u128, a, b, null);39 return udivmod(u128, a, b, null);
59}40}
6041
61fn __udivti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 {
62 return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), null));
63}
64
65pub fn __modti3(a: i128, b: i128) callconv(.c) i128 {42pub fn __modti3(a: i128, b: i128) callconv(.c) i128 {
66 return mod(a, b);43 return mod(a, b);
67}44}
6845
69fn __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
73inline fn mod(a: i128, b: i128) i128 {46inline fn mod(a: i128, b: i128) i128 {
74 const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 047 const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 0
75 const s_b = b >> (128 - 1); // s = b < 0 ? -1 : 048 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,12 +61,6 @@ pub fn __umodti3(a: u128, b: u128) callconv(.c) u128 {
88 return r;61 return r;
89}62}
9063
91fn __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
97const lo = switch (builtin.cpu.arch.endian()) {64const lo = switch (builtin.cpu.arch.endian()) {
98 .big => 1,65 .big => 1,
99 .little => 0,66 .little => 0,