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,