From 3d604248e6c2111ff3dc48057f07ec91fdbc6a9e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alex=20R=C3=B8nne=20Petersen?= <alex@alexrp.com>
Date: Thu, 18 Jun 2026 10:46:19 +0200
Subject: [PATCH] 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.
---
 lib/compiler_rt.zig                |  4 ---
 lib/compiler_rt/fixdfti.zig        | 12 +--------
 lib/compiler_rt/fixsfti.zig        | 12 +--------
 lib/compiler_rt/fixtfti.zig        | 16 +++--------
 lib/compiler_rt/fixunsdfti.zig     | 12 +--------
 lib/compiler_rt/fixunshfti.zig     | 12 +--------
 lib/compiler_rt/fixunssfti.zig     | 12 +--------
 lib/compiler_rt/fixunstfti.zig     | 16 +++--------
 lib/compiler_rt/fixunsxfti.zig     | 12 +--------
 lib/compiler_rt/floattidf.zig      | 10 +------
 lib/compiler_rt/floattihf.zig      | 10 +------
 lib/compiler_rt/floattisf.zig      | 10 +------
 lib/compiler_rt/floattitf.zig      | 14 +++-------
 lib/compiler_rt/floattixf.zig      | 10 +------
 lib/compiler_rt/floatuntidf.zig    | 10 +------
 lib/compiler_rt/floatuntihf.zig    | 10 +------
 lib/compiler_rt/floatuntisf.zig    | 10 +------
 lib/compiler_rt/floatuntitf.zig    | 14 +++-------
 lib/compiler_rt/floatuntixf.zig    | 10 +------
 lib/compiler_rt/int_from_float.zig | 24 ++---------------
 lib/compiler_rt/mulXi3.zig         | 12 +--------
 lib/compiler_rt/udivmod.zig        | 43 ++++--------------------------
 22 files changed, 34 insertions(+), 261 deletions(-)

diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig
index 04370b2fd86f6febda129b81a516173f3f8f6e1d..73bb514565d0ee57ed721b7b366ebea209cff107 100644
--- 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
index 4717fd7b59f1b17854dfc742b73bfd506c1522fd..ff7434d63da148afc20b22bbfb54d6c1bdd17822 100644
--- 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
index 0980012a453eba643ea0af0206d8256bab481990..121eff084d58a00726ed140a0d4f4cacafdce87b 100644
--- 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
index cb642d61664a2780003a78cc0293f80657b516a5..0aac298ca2c4d0fa3f8d7fd02cf1290f98929c2b 100644
--- 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
index 95d15ac3138eab9596b375c50814521c4aac5416..1a634baaf5a6da399abaebb3e236ea5c02005ead 100644
--- 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
index a090027196937f25b649dcd6d8e3d589e7cd4083..3dc7a5f99390d05606bb09298651e1d4482e3ab6 100644
--- 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
index da46f43d5bc111b53ee317a70a0456d3ea554853..6824afcde4b518642189696a47c0983047dd47c3 100644
--- 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
index 81c2a160957c20492c3781353a4042807d7ed0af..78c6b1e8f7b90aa5d90a957920e949bb0aa2cbc0 100644
--- 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
index 24296dd416c85377442b95e1dcdea92ed27a96e7..064c1352c9045870c1a984850f71c86fcf6e8e61 100644
--- 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
index 5fd6b4c0f68782935fb6b90713228dabfab7d928..02298705324edcd49b36f69a64c0c78873ecb57b 100644
--- 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
index 643849f48e25ca2735ab813dd152f3b93015fcbf..a751e3142c5b273819199105a6848c0280aee3c5 100644
--- 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
index 8926105d2df059bccfdf34bebfcff4277c988504..72af61c6b6805d9bd03e6d215dd300fe7589c21f 100644
--- 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
index f8e6ca80e61d65f4c765b94aade334ccd13d1ed1..3e49a68fd56912ebe7573346b6b8aea6b98b91ba 100644
--- 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
index b69b8f9845fa858e5a05133aa4b69a5c11342ca3..be05180795aef517800c15d01c928bab4f7f19a0 100644
--- 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
index 7e08a66b97c4f18a85ec386e4fc8eda16bb972ab..b770457bc4992a5bd6237d832e2ca4c0cbed11e0 100644
--- 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
index 5c50f39eaad5be332c32eb5618e8ff8011f660b1..5b4373cb7c496b0acf1a2fe6ef988872b30e8780 100644
--- 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
index 5a15f7c19d9f6906bb1a485d7101976f2297ac40..de9a021476edecfcc26761133c0645d799c677da 100644
--- 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
index 6df02c5bef9a6d43c54a82e207446d049a0b84e8..47cd65cc3ff4460d937e0ccd7acabb2455ae704a 100644
--- 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
index 27e668109fdc4eaf3315dea7e129aa70393782c7..41fb45b3a3a1b8e213c03a4ef5e847feb8d31211 100644
--- 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
index 494ac6cdc392001e356f713bee733c73b19069e1..320513fb2c7125f4c61f7e90bc7202a05ed31838 100644
--- 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
index 9fce9754f3a748e82e55728e5e18195970e53b52..5766a070fdd9bef9da49d03890a8fa65a004cda8 100644
--- 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
index fdb338c21ac012c786f2fba1c54f9dfc119f0c88..101d23a059d7b08cbc56a392b57134f35e78d696 100644
--- 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,
-- 
2.54.0