commit 3d604248e6c2111ff3dc48057f07ec91fdbc6a9e (tree) parent 84f84267c72b12d4562d53df33e3c0121c7e5cee Author: Alex Rønne Petersen <alex@alexrp.com> Date: Thu, 18 Jun 2026 10:46:19 +0200 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. Diffstat:
22 files changed, 34 insertions(+), 261 deletions(-)
diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig @@ -404,10 +404,6 @@ pub const want_ppc_abi = builtin.cpu.arch.isPowerPC(); pub const want_float_exceptions = !builtin.cpu.arch.isWasm(); -// Libcalls that involve u128 on Windows x86-64 are expected by LLVM to use the -// calling convention of @Vector(2, u64), rather than what's standard. -pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and !ofmt_c; - /// This governs whether to use these symbol names for f16/f32 conversions /// rather than the standard names: /// * __gnu_f2h_ieee diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig @@ -3,19 +3,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat; const symbol = @import("../compiler_rt.zig").symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixdfti_windows_x86_64, "__fixdfti"); - } else { - symbol(&__fixdfti, "__fixdfti"); - } + symbol(&__fixdfti, "__fixdfti"); } pub fn __fixdfti(a: f64) callconv(.c) i128 { return intFromFloat(i128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixdfti_windows_x86_64(a: f64) callconv(.c) v2u64 { - return @bitCast(intFromFloat(i128, a)); -} diff --git a/lib/compiler_rt/fixsfti.zig b/lib/compiler_rt/fixsfti.zig @@ -4,19 +4,9 @@ const symbol = compiler_rt.symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixsfti_windows_x86_64, "__fixsfti"); - } else { - symbol(&__fixsfti, "__fixsfti"); - } + symbol(&__fixsfti, "__fixsfti"); } pub fn __fixsfti(a: f32) callconv(.c) i128 { return intFromFloat(i128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixsfti_windows_x86_64(a: f32) callconv(.c) v2u64 { - return @bitCast(intFromFloat(i128, a)); -} diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig @@ -3,21 +3,11 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat; const symbol = @import("../compiler_rt.zig").symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixtfti_windows_x86_64, "__fixtfti"); - } else { - if (compiler_rt.want_ppc_abi) - symbol(&__fixtfti, "__fixkfti"); - symbol(&__fixtfti, "__fixtfti"); - } + if (compiler_rt.want_ppc_abi) + symbol(&__fixtfti, "__fixkfti"); + symbol(&__fixtfti, "__fixtfti"); } pub fn __fixtfti(a: f128) callconv(.c) i128 { return intFromFloat(i128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixtfti_windows_x86_64(a: f128) callconv(.c) v2u64 { - return @bitCast(intFromFloat(i128, a)); -} diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig @@ -3,19 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixunsdfti_windows_x86_64, "__fixunsdfti"); - } else { - symbol(&__fixunsdfti, "__fixunsdfti"); - } + symbol(&__fixunsdfti, "__fixunsdfti"); } pub fn __fixunsdfti(a: f64) callconv(.c) u128 { return intFromFloat(u128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixunsdfti_windows_x86_64(a: f64) callconv(.c) v2u64 { - return @bitCast(intFromFloat(u128, a)); -} diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig @@ -3,19 +3,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat; const symbol = @import("../compiler_rt.zig").symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixunshfti_windows_x86_64, "__fixunshfti"); - } else { - symbol(&__fixunshfti, "__fixunshfti"); - } + symbol(&__fixunshfti, "__fixunshfti"); } pub fn __fixunshfti(a: f16) callconv(.c) u128 { return intFromFloat(u128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixunshfti_windows_x86_64(a: f16) callconv(.c) v2u64 { - return @bitCast(intFromFloat(u128, a)); -} diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig @@ -4,19 +4,9 @@ const intFromFloat = @import("./int_from_float.zig").intFromFloat; const symbol = @import("../compiler_rt.zig").symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixunssfti_windows_x86_64, "__fixunssfti"); - } else { - symbol(&__fixunssfti, "__fixunssfti"); - } + symbol(&__fixunssfti, "__fixunssfti"); } pub fn __fixunssfti(a: f32) callconv(.c) u128 { return intFromFloat(u128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixunssfti_windows_x86_64(a: f32) callconv(.c) v2u64 { - return @bitCast(intFromFloat(u128, a)); -} diff --git a/lib/compiler_rt/fixunstfti.zig b/lib/compiler_rt/fixunstfti.zig @@ -4,21 +4,11 @@ const symbol = compiler_rt.symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixunstfti_windows_x86_64, "__fixunstfti"); - } else { - if (compiler_rt.want_ppc_abi) - symbol(&__fixunstfti, "__fixunskfti"); - symbol(&__fixunstfti, "__fixunstfti"); - } + if (compiler_rt.want_ppc_abi) + symbol(&__fixunstfti, "__fixunskfti"); + symbol(&__fixunstfti, "__fixunstfti"); } pub fn __fixunstfti(a: f128) callconv(.c) u128 { return intFromFloat(u128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixunstfti_windows_x86_64(a: f128) callconv(.c) v2u64 { - return @bitCast(intFromFloat(u128, a)); -} diff --git a/lib/compiler_rt/fixunsxfti.zig b/lib/compiler_rt/fixunsxfti.zig @@ -4,19 +4,9 @@ const symbol = compiler_rt.symbol; const intFromFloat = @import("./int_from_float.zig").intFromFloat; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixunsxfti_windows_x86_64, "__fixunsxfti"); - } else { - symbol(&__fixunsxfti, "__fixunsxfti"); - } + symbol(&__fixunsxfti, "__fixunsxfti"); } pub fn __fixunsxfti(a: f80) callconv(.c) u128 { return intFromFloat(u128, a); } - -const v2u64 = @Vector(2, u64); - -fn __fixunsxfti_windows_x86_64(a: f80) callconv(.c) v2u64 { - return @bitCast(intFromFloat(u128, a)); -} diff --git a/lib/compiler_rt/floattidf.zig b/lib/compiler_rt/floattidf.zig @@ -3,17 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floattidf_windows_x86_64, "__floattidf"); - } else { - symbol(&__floattidf, "__floattidf"); - } + symbol(&__floattidf, "__floattidf"); } pub fn __floattidf(a: i128) callconv(.c) f64 { return floatFromInt(f64, a); } - -fn __floattidf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f64 { - return floatFromInt(f64, @as(i128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floattihf.zig b/lib/compiler_rt/floattihf.zig @@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floattihf_windows_x86_64, "__floattihf"); - } else { - symbol(&__floattihf, "__floattihf"); - } + symbol(&__floattihf, "__floattihf"); } pub fn __floattihf(a: i128) callconv(.c) f16 { return floatFromInt(f16, a); } - -fn __floattihf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f16 { - return floatFromInt(f16, @as(i128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floattisf.zig b/lib/compiler_rt/floattisf.zig @@ -3,17 +3,9 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt; const symbol = @import("../compiler_rt.zig").symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floattisf_windows_x86_64, "__floattisf"); - } else { - symbol(&__floattisf, "__floattisf"); - } + symbol(&__floattisf, "__floattisf"); } pub fn __floattisf(a: i128) callconv(.c) f32 { return floatFromInt(f32, a); } - -fn __floattisf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f32 { - return floatFromInt(f32, @as(i128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floattitf.zig b/lib/compiler_rt/floattitf.zig @@ -3,19 +3,11 @@ const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floattitf_windows_x86_64, "__floattitf"); - } else { - if (compiler_rt.want_ppc_abi) - symbol(&__floattitf, "__floattikf"); - symbol(&__floattitf, "__floattitf"); - } + if (compiler_rt.want_ppc_abi) + symbol(&__floattitf, "__floattikf"); + symbol(&__floattitf, "__floattitf"); } pub fn __floattitf(a: i128) callconv(.c) f128 { return floatFromInt(f128, a); } - -fn __floattitf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f128 { - return floatFromInt(f128, @as(i128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floattixf.zig b/lib/compiler_rt/floattixf.zig @@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floattixf_windows_x86_64, "__floattixf"); - } else { - symbol(&__floattixf, "__floattixf"); - } + symbol(&__floattixf, "__floattixf"); } pub fn __floattixf(a: i128) callconv(.c) f80 { return floatFromInt(f80, a); } - -fn __floattixf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f80 { - return floatFromInt(f80, @as(i128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floatuntidf.zig b/lib/compiler_rt/floatuntidf.zig @@ -3,17 +3,9 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt; const symbol = @import("../compiler_rt.zig").symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floatuntidf_windows_x86_64, "__floatuntidf"); - } else { - symbol(&__floatuntidf, "__floatuntidf"); - } + symbol(&__floatuntidf, "__floatuntidf"); } pub fn __floatuntidf(a: u128) callconv(.c) f64 { return floatFromInt(f64, a); } - -fn __floatuntidf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f64 { - return floatFromInt(f64, @as(u128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floatuntihf.zig b/lib/compiler_rt/floatuntihf.zig @@ -3,17 +3,9 @@ const symbol = @import("../compiler_rt.zig").symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floatuntihf_windows_x86_64, "__floatuntihf"); - } else { - symbol(&__floatuntihf, "__floatuntihf"); - } + symbol(&__floatuntihf, "__floatuntihf"); } pub fn __floatuntihf(a: u128) callconv(.c) f16 { return floatFromInt(f16, a); } - -fn __floatuntihf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f16 { - return floatFromInt(f16, @as(u128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floatuntisf.zig b/lib/compiler_rt/floatuntisf.zig @@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floatuntisf_windows_x86_64, "__floatuntisf"); - } else { - symbol(&__floatuntisf, "__floatuntisf"); - } + symbol(&__floatuntisf, "__floatuntisf"); } pub fn __floatuntisf(a: u128) callconv(.c) f32 { return floatFromInt(f32, a); } - -fn __floatuntisf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f32 { - return floatFromInt(f32, @as(u128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig @@ -3,19 +3,11 @@ const floatFromInt = @import("./float_from_int.zig").floatFromInt; const symbol = @import("../compiler_rt.zig").symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floatuntitf_windows_x86_64, "__floatuntitf"); - } else { - if (compiler_rt.want_ppc_abi) - symbol(&__floatuntitf, "__floatuntikf"); - symbol(&__floatuntitf, "__floatuntitf"); - } + if (compiler_rt.want_ppc_abi) + symbol(&__floatuntitf, "__floatuntikf"); + symbol(&__floatuntitf, "__floatuntitf"); } pub fn __floatuntitf(a: u128) callconv(.c) f128 { return floatFromInt(f128, a); } - -fn __floatuntitf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f128 { - return floatFromInt(f128, @as(u128, @bitCast(a))); -} diff --git a/lib/compiler_rt/floatuntixf.zig b/lib/compiler_rt/floatuntixf.zig @@ -4,17 +4,9 @@ const symbol = compiler_rt.symbol; const floatFromInt = @import("./float_from_int.zig").floatFromInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__floatuntixf_windows_x86_64, "__floatuntixf"); - } else { - symbol(&__floatuntixf, "__floatuntixf"); - } + symbol(&__floatuntixf, "__floatuntixf"); } pub fn __floatuntixf(a: u128) callconv(.c) f80 { return floatFromInt(f80, a); } - -fn __floatuntixf_windows_x86_64(a: @Vector(2, u64)) callconv(.c) f80 { - return floatFromInt(f80, @as(u128, @bitCast(a))); -} diff --git a/lib/compiler_rt/int_from_float.zig b/lib/compiler_rt/int_from_float.zig @@ -6,32 +6,16 @@ const compiler_rt = @import("../compiler_rt.zig"); const symbol = compiler_rt.symbol; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixxfti_windows_x86_64, "__fixxfti"); - } else { - symbol(&__fixxfti, "__fixxfti"); - } - + symbol(&__fixxfti, "__fixxfti"); symbol(&__fixhfsi, "__fixhfsi"); symbol(&__fixhfdi, "__fixhfdi"); - - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__fixhfti_windows_x86_64, "__fixhfti"); - } else { - symbol(&__fixhfti, "__fixhfti"); - } + symbol(&__fixhfti, "__fixhfti"); } -const v2u64 = @Vector(2, u64); - pub fn __fixhfti(a: f16) callconv(.c) i128 { return intFromFloat(i128, a); } -fn __fixhfti_windows_x86_64(a: f16) callconv(.c) v2u64 { - return @bitCast(intFromFloat(i128, a)); -} - fn __fixhfdi(a: f16) callconv(.c) i64 { return intFromFloat(i64, a); } @@ -44,10 +28,6 @@ pub fn __fixxfti(a: f80) callconv(.c) i128 { return intFromFloat(i128, a); } -fn __fixxfti_windows_x86_64(a: f80) callconv(.c) v2u64 { - return @bitCast(intFromFloat(i128, a)); -} - pub inline fn intFromFloat(comptime I: type, a: anytype) I { const F = @TypeOf(a); const float_bits = @typeInfo(F).float.bits; diff --git a/lib/compiler_rt/mulXi3.zig b/lib/compiler_rt/mulXi3.zig @@ -12,11 +12,7 @@ comptime { } else { symbol(&__muldi3, "__muldi3"); } - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__multi3_windows_x86_64, "__multi3"); - } else { - symbol(&__multi3, "__multi3"); - } + symbol(&__multi3, "__multi3"); } pub fn __mulsi3(a: i32, b: i32) callconv(.c) i32 { @@ -89,12 +85,6 @@ pub fn __multi3(a: i128, b: i128) callconv(.c) i128 { return mulX(i128, a, b); } -const v2u64 = @Vector(2, u64); - -fn __multi3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 { - return @bitCast(mulX(i128, @as(i128, @bitCast(a)), @as(i128, @bitCast(b)))); -} - test { _ = @import("mulXi3_test.zig"); } diff --git a/lib/compiler_rt/udivmod.zig b/lib/compiler_rt/udivmod.zig @@ -8,40 +8,21 @@ const symbol = compiler_rt.symbol; const HalveInt = compiler_rt.HalveInt; comptime { - if (compiler_rt.want_windows_v2u64_abi) { - symbol(&__umodti3_windows_x86_64, "__umodti3"); - symbol(&__modti3_windows_x86_64, "__modti3"); - symbol(&__udivti3_windows_x86_64, "__udivti3"); - symbol(&__divti3_windows_x86_64, "__divti3"); - symbol(&__udivmodti4_windows_x86_64, "__udivmodti4"); - } else { - symbol(&__umodti3, "__umodti3"); - symbol(&__modti3, "__modti3"); - symbol(&__udivti3, "__udivti3"); - symbol(&__divti3, "__divti3"); - symbol(&__udivmodti4, "__udivmodti4"); - } + symbol(&__umodti3, "__umodti3"); + symbol(&__modti3, "__modti3"); + symbol(&__udivti3, "__udivti3"); + symbol(&__divti3, "__divti3"); + symbol(&__udivmodti4, "__udivmodti4"); } -const v128 = @Vector(2, u64); -const v2u64 = @Vector(2, u64); - pub fn __udivmodti4(a: u128, b: u128, maybe_rem: ?*u128) callconv(.c) u128 { return udivmod(u128, a, b, maybe_rem); } -fn __udivmodti4_windows_x86_64(a: v2u64, b: v2u64, maybe_rem: ?*u128) callconv(.c) v2u64 { - return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), maybe_rem)); -} - pub fn __divti3(a: i128, b: i128) callconv(.c) i128 { return div(a, b); } -fn __divti3_windows_x86_64(a: v128, b: v128) callconv(.c) v128 { - return @bitCast(div(@bitCast(a), @bitCast(b))); -} - inline fn div(a: i128, b: i128) i128 { const s_a = a >> (128 - 1); const s_b = b >> (128 - 1); @@ -58,18 +39,10 @@ pub fn __udivti3(a: u128, b: u128) callconv(.c) u128 { return udivmod(u128, a, b, null); } -fn __udivti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 { - return @bitCast(udivmod(u128, @bitCast(a), @bitCast(b), null)); -} - pub fn __modti3(a: i128, b: i128) callconv(.c) i128 { return mod(a, b); } -fn __modti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 { - return @bitCast(mod(@as(i128, @bitCast(a)), @as(i128, @bitCast(b)))); -} - inline fn mod(a: i128, b: i128) i128 { const s_a = a >> (128 - 1); // s = a < 0 ? -1 : 0 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 { return r; } -fn __umodti3_windows_x86_64(a: v2u64, b: v2u64) callconv(.c) v2u64 { - var r: u128 = undefined; - _ = udivmod(u128, @bitCast(a), @bitCast(b), &r); - return @bitCast(r); -} - const lo = switch (builtin.cpu.arch.endian()) { .big => 1, .little => 0,