diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7329c059180e9b2afa353dcbd548b084983b38fa..a393249458ec49df8dc91038f4f93d2a4a6ae772 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -480,7 +480,14 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/lib/std/sort.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/absv.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/addXf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/addf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/addsf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/addtf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/addxf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/subdf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/subsf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/subtf3.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/subxf3.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/addo.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/arm.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/atomics.zig"
@@ -491,7 +498,18 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/clear_cache.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmp.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/common.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/compareXf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/comparef.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmpsf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmpdf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmptf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/cmpxf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/gesf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/gedf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/getf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/gexf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/unordsf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/unorddf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/unordtf2.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/cos.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/count0bits.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/divdf3.zig"
@@ -502,11 +520,79 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/emutls.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/exp.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/exp2.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendXfYf2.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extend_f80.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extenddftf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extenddfxf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendhfsf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendhftf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendhfxf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendsfdf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendsftf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendsfxf2.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/extendxftf2.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fabs.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixXfYi.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatXiYf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/int_to_float.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsihf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsisf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsidf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsitf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatsixf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdihf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdisf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdidf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatditf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatdixf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattihf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattisf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattidf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattitf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floattixf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundihf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundisf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundidf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunditf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatundixf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsihf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsisf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsidf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsitf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatunsixf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntihf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntisf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntidf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntitf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floatuntixf.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/float_to_int.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixhfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixhfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixhfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixsfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixsfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixsfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixdfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixdfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixdfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixtfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixtfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixtfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixxfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixxfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixxfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunshfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunshfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunshfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunssfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunssfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunssfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsdfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsdfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsdfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunstfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunstfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunstfti.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsxfsi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsxfdi.zig"
+    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fixunsxfti.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/floor.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fma.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/fmax.zig"
@@ -517,7 +603,6 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/log10.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/log2.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/modti3.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/mulXf3.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/muldi3.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/mulo.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/multi3.zig"
@@ -541,8 +626,6 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/tan.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/trig.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/trunc.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/truncXfYf2.zig"
-    "${CMAKE_SOURCE_DIR}/lib/compiler_rt/trunc_f80.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/udivmod.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/udivmodti4.zig"
     "${CMAKE_SOURCE_DIR}/lib/compiler_rt/udivti3.zig"
diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig
index fec4573f468bda8d0b3669bc4001a31bc391de62..826530286d4442601ba8efacc36a7f78b43a83cb 100644
--- a/lib/compiler_rt.zig
+++ b/lib/compiler_rt.zig
@@ -1,18 +1,59 @@
-const builtin = @import("builtin");
 pub const panic = @import("compiler_rt/common.zig").panic;
 
 comptime {
-    // TODO moving these around makes or breaks compilation of zig1.o for some reason
-    // Perhaps, until we switch to stage2, exports should be duplicated between this file
-    // and files included as a standalone units?
     _ = @import("compiler_rt/atomics.zig");
-    _ = @import("compiler_rt/addXf3.zig");
-    _ = @import("compiler_rt/mulXf3.zig");
-    _ = @import("compiler_rt/compareXf2.zig");
-    _ = @import("compiler_rt/extendXfYf2.zig");
-    _ = @import("compiler_rt/extend_f80.zig");
-    _ = @import("compiler_rt/truncXfYf2.zig");
-    _ = @import("compiler_rt/trunc_f80.zig");
+
+    _ = @import("compiler_rt/addf3.zig");
+    _ = @import("compiler_rt/addsf3.zig");
+    _ = @import("compiler_rt/addtf3.zig");
+    _ = @import("compiler_rt/addxf3.zig");
+    _ = @import("compiler_rt/subdf3.zig");
+    _ = @import("compiler_rt/subsf3.zig");
+    _ = @import("compiler_rt/subtf3.zig");
+    _ = @import("compiler_rt/subxf3.zig");
+
+    _ = @import("compiler_rt/mulf3.zig");
+    _ = @import("compiler_rt/muldf3.zig");
+    _ = @import("compiler_rt/mulsf3.zig");
+    _ = @import("compiler_rt/multf3.zig");
+    _ = @import("compiler_rt/mulxf3.zig");
+
+    _ = @import("compiler_rt/comparef.zig");
+    _ = @import("compiler_rt/cmpsf2.zig");
+    _ = @import("compiler_rt/cmpdf2.zig");
+    _ = @import("compiler_rt/cmptf2.zig");
+    _ = @import("compiler_rt/cmpxf2.zig");
+    _ = @import("compiler_rt/gesf2.zig");
+    _ = @import("compiler_rt/gedf2.zig");
+    _ = @import("compiler_rt/getf2.zig");
+    _ = @import("compiler_rt/gexf2.zig");
+    _ = @import("compiler_rt/unordsf2.zig");
+    _ = @import("compiler_rt/unorddf2.zig");
+    _ = @import("compiler_rt/unordtf2.zig");
+
+    _ = @import("compiler_rt/extendf.zig");
+    _ = @import("compiler_rt/extenddftf2.zig");
+    _ = @import("compiler_rt/extenddfxf2.zig");
+    _ = @import("compiler_rt/extendhfsf2.zig");
+    _ = @import("compiler_rt/extendhftf2.zig");
+    _ = @import("compiler_rt/extendhfxf2.zig");
+    _ = @import("compiler_rt/extendsfdf2.zig");
+    _ = @import("compiler_rt/extendsftf2.zig");
+    _ = @import("compiler_rt/extendsfxf2.zig");
+    _ = @import("compiler_rt/extendxftf2.zig");
+
+    _ = @import("compiler_rt/truncf.zig");
+    _ = @import("compiler_rt/truncsfhf2.zig");
+    _ = @import("compiler_rt/truncdfhf2.zig");
+    _ = @import("compiler_rt/truncdfsf2.zig");
+    _ = @import("compiler_rt/trunctfhf2.zig");
+    _ = @import("compiler_rt/trunctfsf2.zig");
+    _ = @import("compiler_rt/trunctfdf2.zig");
+    _ = @import("compiler_rt/trunctfxf2.zig");
+    _ = @import("compiler_rt/truncxfhf2.zig");
+    _ = @import("compiler_rt/truncxfsf2.zig");
+    _ = @import("compiler_rt/truncxfdf2.zig");
+
     _ = @import("compiler_rt/divtf3.zig");
     _ = @import("compiler_rt/divsf3.zig");
     _ = @import("compiler_rt/divdf3.zig");
@@ -43,35 +84,101 @@ comptime {
     _ = @import("compiler_rt/udivti3.zig");
     _ = @import("compiler_rt/udivmodti4.zig");
     _ = @import("compiler_rt/umodti3.zig");
-    _ = @import("compiler_rt/floatXiYf.zig");
-    _ = @import("compiler_rt/fixXfYi.zig");
+
+    _ = @import("compiler_rt/int_to_float.zig");
+    _ = @import("compiler_rt/floatsihf.zig");
+    _ = @import("compiler_rt/floatsisf.zig");
+    _ = @import("compiler_rt/floatsidf.zig");
+    _ = @import("compiler_rt/floatsitf.zig");
+    _ = @import("compiler_rt/floatsixf.zig");
+    _ = @import("compiler_rt/floatdihf.zig");
+    _ = @import("compiler_rt/floatdisf.zig");
+    _ = @import("compiler_rt/floatdidf.zig");
+    _ = @import("compiler_rt/floatditf.zig");
+    _ = @import("compiler_rt/floatdixf.zig");
+    _ = @import("compiler_rt/floattihf.zig");
+    _ = @import("compiler_rt/floattisf.zig");
+    _ = @import("compiler_rt/floattidf.zig");
+    _ = @import("compiler_rt/floattitf.zig");
+    _ = @import("compiler_rt/floattixf.zig");
+    _ = @import("compiler_rt/floatundihf.zig");
+    _ = @import("compiler_rt/floatundisf.zig");
+    _ = @import("compiler_rt/floatundidf.zig");
+    _ = @import("compiler_rt/floatunditf.zig");
+    _ = @import("compiler_rt/floatundixf.zig");
+    _ = @import("compiler_rt/floatunsihf.zig");
+    _ = @import("compiler_rt/floatunsisf.zig");
+    _ = @import("compiler_rt/floatunsidf.zig");
+    _ = @import("compiler_rt/floatunsitf.zig");
+    _ = @import("compiler_rt/floatunsixf.zig");
+    _ = @import("compiler_rt/floatuntihf.zig");
+    _ = @import("compiler_rt/floatuntisf.zig");
+    _ = @import("compiler_rt/floatuntidf.zig");
+    _ = @import("compiler_rt/floatuntitf.zig");
+    _ = @import("compiler_rt/floatuntixf.zig");
+
+    _ = @import("compiler_rt/float_to_int.zig");
+    _ = @import("compiler_rt/fixhfsi.zig");
+    _ = @import("compiler_rt/fixhfdi.zig");
+    _ = @import("compiler_rt/fixhfti.zig");
+    _ = @import("compiler_rt/fixsfsi.zig");
+    _ = @import("compiler_rt/fixsfdi.zig");
+    _ = @import("compiler_rt/fixsfti.zig");
+    _ = @import("compiler_rt/fixdfsi.zig");
+    _ = @import("compiler_rt/fixdfdi.zig");
+    _ = @import("compiler_rt/fixdfti.zig");
+    _ = @import("compiler_rt/fixtfsi.zig");
+    _ = @import("compiler_rt/fixtfdi.zig");
+    _ = @import("compiler_rt/fixtfti.zig");
+    _ = @import("compiler_rt/fixxfsi.zig");
+    _ = @import("compiler_rt/fixxfdi.zig");
+    _ = @import("compiler_rt/fixxfti.zig");
+    _ = @import("compiler_rt/fixunshfsi.zig");
+    _ = @import("compiler_rt/fixunshfdi.zig");
+    _ = @import("compiler_rt/fixunshfti.zig");
+    _ = @import("compiler_rt/fixunssfsi.zig");
+    _ = @import("compiler_rt/fixunssfdi.zig");
+    _ = @import("compiler_rt/fixunssfti.zig");
+    _ = @import("compiler_rt/fixunsdfsi.zig");
+    _ = @import("compiler_rt/fixunsdfdi.zig");
+    _ = @import("compiler_rt/fixunsdfti.zig");
+    _ = @import("compiler_rt/fixunstfsi.zig");
+    _ = @import("compiler_rt/fixunstfdi.zig");
+    _ = @import("compiler_rt/fixunstfti.zig");
+    _ = @import("compiler_rt/fixunsxfsi.zig");
+    _ = @import("compiler_rt/fixunsxfdi.zig");
+    _ = @import("compiler_rt/fixunsxfti.zig");
+
     _ = @import("compiler_rt/count0bits.zig");
     _ = @import("compiler_rt/parity.zig");
     _ = @import("compiler_rt/popcount.zig");
     _ = @import("compiler_rt/bswap.zig");
     _ = @import("compiler_rt/int.zig");
     _ = @import("compiler_rt/shift.zig");
+
     _ = @import("compiler_rt/negXi2.zig");
+
     _ = @import("compiler_rt/muldi3.zig");
+
     _ = @import("compiler_rt/absv.zig");
+    _ = @import("compiler_rt/absvsi2.zig");
+    _ = @import("compiler_rt/absvdi2.zig");
+    _ = @import("compiler_rt/absvti2.zig");
+
     _ = @import("compiler_rt/negv.zig");
     _ = @import("compiler_rt/addo.zig");
     _ = @import("compiler_rt/subo.zig");
     _ = @import("compiler_rt/mulo.zig");
     _ = @import("compiler_rt/cmp.zig");
+
     _ = @import("compiler_rt/negXf2.zig");
+
     _ = @import("compiler_rt/os_version_check.zig");
     _ = @import("compiler_rt/emutls.zig");
     _ = @import("compiler_rt/arm.zig");
     _ = @import("compiler_rt/aulldiv.zig");
     _ = @import("compiler_rt/aullrem.zig");
-    _ = @import("compiler_rt/sparc.zig");
     _ = @import("compiler_rt/clear_cache.zig");
 
-    // missing: Floating point raised to integer power
-
-    // missing: Complex arithmetic
-    // (a + ib) * (c + id)
-    // (a + ib) / (c + id)
-
+    _ = @import("compiler_rt/sparc.zig");
 }
diff --git a/lib/compiler_rt/absv.zig b/lib/compiler_rt/absv.zig
index 3d9476b6c780c6fe23d5623ccd7a6a29a3f56263..8910a4a6b9417bd099065db02f1535ace9968ee0 100644
--- a/lib/compiler_rt/absv.zig
+++ b/lib/compiler_rt/absv.zig
@@ -1,18 +1,6 @@
-// absv - absolute oVerflow
-// * @panic, if value can not be represented
-// - absvXi4_generic for unoptimized version
-const std = @import("std");
-const builtin = @import("builtin");
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    @export(__absvsi2, .{ .name = "__absvsi2", .linkage = linkage });
-    @export(__absvdi2, .{ .name = "__absvdi2", .linkage = linkage });
-    @export(__absvti2, .{ .name = "__absvti2", .linkage = linkage });
-}
-
-inline fn absvXi(comptime ST: type, a: ST) ST {
+/// absv - absolute oVerflow
+/// * @panic if value can not be represented
+pub inline fn absv(comptime ST: type, a: ST) ST {
     const UT = switch (ST) {
         i32 => u32,
         i64 => u64,
@@ -31,18 +19,6 @@ inline fn absvXi(comptime ST: type, a: ST) ST {
     return x;
 }
 
-pub fn __absvsi2(a: i32) callconv(.C) i32 {
-    return absvXi(i32, a);
-}
-
-pub fn __absvdi2(a: i64) callconv(.C) i64 {
-    return absvXi(i64, a);
-}
-
-pub fn __absvti2(a: i128) callconv(.C) i128 {
-    return absvXi(i128, a);
-}
-
 test {
     _ = @import("absvsi2_test.zig");
     _ = @import("absvdi2_test.zig");
diff --git a/lib/compiler_rt/absvdi2.zig b/lib/compiler_rt/absvdi2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1875d5bbaac803e41350041b819b0e95a22f1f45
--- /dev/null
+++ b/lib/compiler_rt/absvdi2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const absv = @import("./absv.zig").absv;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__absvdi2, .{ .name = "__absvdi2", .linkage = common.linkage });
+}
+
+fn __absvdi2(a: i64) callconv(.C) i64 {
+    return absv(i64, a);
+}
diff --git a/lib/compiler_rt/absvsi2.zig b/lib/compiler_rt/absvsi2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..965e39bc9b23b4fc5c3454cdb81cfbd4a9b6aec5
--- /dev/null
+++ b/lib/compiler_rt/absvsi2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const absv = @import("./absv.zig").absv;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__absvsi2, .{ .name = "__absvsi2", .linkage = common.linkage });
+}
+
+fn __absvsi2(a: i32) callconv(.C) i32 {
+    return absv(i32, a);
+}
diff --git a/lib/compiler_rt/absvti2.zig b/lib/compiler_rt/absvti2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ada06c6563e8fd3be0527903b5cc1810f70c1dcb
--- /dev/null
+++ b/lib/compiler_rt/absvti2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const absv = @import("./absv.zig").absv;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__absvti2, .{ .name = "__absvti2", .linkage = common.linkage });
+}
+
+fn __absvti2(a: i128) callconv(.C) i128 {
+    return absv(i128, a);
+}
diff --git a/lib/compiler_rt/addXf3.zig b/lib/compiler_rt/addXf3.zig
deleted file mode 100644
index e2cf9d0112d1d87e75357fe9e29f182a2e341bfc..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/addXf3.zig
+++ /dev/null
@@ -1,271 +0,0 @@
-// Ported from:
-//
-// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/lib/builtins/fp_add_impl.inc
-
-const std = @import("std");
-const builtin = @import("builtin");
-const math = std.math;
-const arch = builtin.cpu.arch;
-const is_test = builtin.is_test;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-
-const common = @import("common.zig");
-const normalize = common.normalize;
-pub const panic = common.panic;
-
-comptime {
-    @export(__addsf3, .{ .name = "__addsf3", .linkage = linkage });
-    @export(__adddf3, .{ .name = "__adddf3", .linkage = linkage });
-    @export(__addxf3, .{ .name = "__addxf3", .linkage = linkage });
-    @export(__addtf3, .{ .name = "__addtf3", .linkage = linkage });
-
-    @export(__subsf3, .{ .name = "__subsf3", .linkage = linkage });
-    @export(__subdf3, .{ .name = "__subdf3", .linkage = linkage });
-    @export(__subxf3, .{ .name = "__subxf3", .linkage = linkage });
-    @export(__subtf3, .{ .name = "__subtf3", .linkage = linkage });
-
-    if (!is_test) {
-        if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = linkage });
-            @export(__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = linkage });
-            @export(__aeabi_fsub, .{ .name = "__aeabi_fsub", .linkage = linkage });
-            @export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = linkage });
-        }
-
-        if (arch.isPPC() or arch.isPPC64()) {
-            @export(__addkf3, .{ .name = "__addkf3", .linkage = linkage });
-            @export(__subkf3, .{ .name = "__subkf3", .linkage = linkage });
-        }
-    }
-}
-
-pub fn __addsf3(a: f32, b: f32) callconv(.C) f32 {
-    return addXf3(f32, a, b);
-}
-
-pub fn __adddf3(a: f64, b: f64) callconv(.C) f64 {
-    return addXf3(f64, a, b);
-}
-
-pub fn __addxf3(a: f80, b: f80) callconv(.C) f80 {
-    return addXf3(f80, a, b);
-}
-
-pub fn __subxf3(a: f80, b: f80) callconv(.C) f80 {
-    var b_rep = std.math.break_f80(b);
-    b_rep.exp ^= 0x8000;
-    return __addxf3(a, std.math.make_f80(b_rep));
-}
-
-pub fn __addtf3(a: f128, b: f128) callconv(.C) f128 {
-    return addXf3(f128, a, b);
-}
-
-pub fn __addkf3(a: f128, b: f128) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __addtf3, .{ a, b });
-}
-
-pub fn __subsf3(a: f32, b: f32) callconv(.C) f32 {
-    const neg_b = @bitCast(f32, @bitCast(u32, b) ^ (@as(u32, 1) << 31));
-    return addXf3(f32, a, neg_b);
-}
-
-pub fn __subdf3(a: f64, b: f64) callconv(.C) f64 {
-    const neg_b = @bitCast(f64, @bitCast(u64, b) ^ (@as(u64, 1) << 63));
-    return addXf3(f64, a, neg_b);
-}
-
-pub fn __subtf3(a: f128, b: f128) callconv(.C) f128 {
-    const neg_b = @bitCast(f128, @bitCast(u128, b) ^ (@as(u128, 1) << 127));
-    return addXf3(f128, a, neg_b);
-}
-
-pub fn __subkf3(a: f128, b: f128) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __subtf3, .{ a, b });
-}
-
-pub fn __aeabi_fadd(a: f32, b: f32) callconv(.AAPCS) f32 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __addsf3, .{ a, b });
-}
-
-pub fn __aeabi_dadd(a: f64, b: f64) callconv(.AAPCS) f64 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __adddf3, .{ a, b });
-}
-
-pub fn __aeabi_fsub(a: f32, b: f32) callconv(.AAPCS) f32 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __subsf3, .{ a, b });
-}
-
-pub fn __aeabi_dsub(a: f64, b: f64) callconv(.AAPCS) f64 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __subdf3, .{ a, b });
-}
-
-// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
-pub fn addXf3(comptime T: type, a: T, b: T) T {
-    const bits = @typeInfo(T).Float.bits;
-    const Z = std.meta.Int(.unsigned, bits);
-    const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1));
-
-    const typeWidth = bits;
-    const significandBits = math.floatMantissaBits(T);
-    const fractionalBits = math.floatFractionalBits(T);
-    const exponentBits = math.floatExponentBits(T);
-
-    const signBit = (@as(Z, 1) << (significandBits + exponentBits));
-    const maxExponent = ((1 << exponentBits) - 1);
-
-    const integerBit = (@as(Z, 1) << fractionalBits);
-    const quietBit = integerBit >> 1;
-    const significandMask = (@as(Z, 1) << significandBits) - 1;
-
-    const absMask = signBit - 1;
-    const qnanRep = @bitCast(Z, math.nan(T)) | quietBit;
-
-    var aRep = @bitCast(Z, a);
-    var bRep = @bitCast(Z, b);
-    const aAbs = aRep & absMask;
-    const bAbs = bRep & absMask;
-
-    const infRep = @bitCast(Z, math.inf(T));
-
-    // Detect if a or b is zero, infinity, or NaN.
-    if (aAbs -% @as(Z, 1) >= infRep - @as(Z, 1) or
-        bAbs -% @as(Z, 1) >= infRep - @as(Z, 1))
-    {
-        // NaN + anything = qNaN
-        if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
-        // anything + NaN = qNaN
-        if (bAbs > infRep) return @bitCast(T, @bitCast(Z, b) | quietBit);
-
-        if (aAbs == infRep) {
-            // +/-infinity + -/+infinity = qNaN
-            if ((@bitCast(Z, a) ^ @bitCast(Z, b)) == signBit) {
-                return @bitCast(T, qnanRep);
-            }
-            // +/-infinity + anything remaining = +/- infinity
-            else {
-                return a;
-            }
-        }
-
-        // anything remaining + +/-infinity = +/-infinity
-        if (bAbs == infRep) return b;
-
-        // zero + anything = anything
-        if (aAbs == 0) {
-            // but we need to get the sign right for zero + zero
-            if (bAbs == 0) {
-                return @bitCast(T, @bitCast(Z, a) & @bitCast(Z, b));
-            } else {
-                return b;
-            }
-        }
-
-        // anything + zero = anything
-        if (bAbs == 0) return a;
-    }
-
-    // Swap a and b if necessary so that a has the larger absolute value.
-    if (bAbs > aAbs) {
-        const temp = aRep;
-        aRep = bRep;
-        bRep = temp;
-    }
-
-    // Extract the exponent and significand from the (possibly swapped) a and b.
-    var aExponent = @intCast(i32, (aRep >> significandBits) & maxExponent);
-    var bExponent = @intCast(i32, (bRep >> significandBits) & maxExponent);
-    var aSignificand = aRep & significandMask;
-    var bSignificand = bRep & significandMask;
-
-    // Normalize any denormals, and adjust the exponent accordingly.
-    if (aExponent == 0) aExponent = normalize(T, &aSignificand);
-    if (bExponent == 0) bExponent = normalize(T, &bSignificand);
-
-    // The sign of the result is the sign of the larger operand, a.  If they
-    // have opposite signs, we are performing a subtraction; otherwise addition.
-    const resultSign = aRep & signBit;
-    const subtraction = (aRep ^ bRep) & signBit != 0;
-
-    // Shift the significands to give us round, guard and sticky, and or in the
-    // implicit significand bit.  (If we fell through from the denormal path it
-    // was already set by normalize( ), but setting it twice won't hurt
-    // anything.)
-    aSignificand = (aSignificand | integerBit) << 3;
-    bSignificand = (bSignificand | integerBit) << 3;
-
-    // Shift the significand of b by the difference in exponents, with a sticky
-    // bottom bit to get rounding correct.
-    const @"align" = @intCast(u32, aExponent - bExponent);
-    if (@"align" != 0) {
-        if (@"align" < typeWidth) {
-            const sticky = if (bSignificand << @intCast(S, typeWidth - @"align") != 0) @as(Z, 1) else 0;
-            bSignificand = (bSignificand >> @truncate(S, @"align")) | sticky;
-        } else {
-            bSignificand = 1; // sticky; b is known to be non-zero.
-        }
-    }
-    if (subtraction) {
-        aSignificand -= bSignificand;
-        // If a == -b, return +zero.
-        if (aSignificand == 0) return @bitCast(T, @as(Z, 0));
-
-        // If partial cancellation occured, we need to left-shift the result
-        // and adjust the exponent:
-        if (aSignificand < integerBit << 3) {
-            const shift = @intCast(i32, @clz(Z, aSignificand)) - @intCast(i32, @clz(std.meta.Int(.unsigned, bits), integerBit << 3));
-            aSignificand <<= @intCast(S, shift);
-            aExponent -= shift;
-        }
-    } else { // addition
-        aSignificand += bSignificand;
-
-        // If the addition carried up, we need to right-shift the result and
-        // adjust the exponent:
-        if (aSignificand & (integerBit << 4) != 0) {
-            const sticky = aSignificand & 1;
-            aSignificand = aSignificand >> 1 | sticky;
-            aExponent += 1;
-        }
-    }
-
-    // If we have overflowed the type, return +/- infinity:
-    if (aExponent >= maxExponent) return @bitCast(T, infRep | resultSign);
-
-    if (aExponent <= 0) {
-        // Result is denormal; the exponent and round/sticky bits are zero.
-        // All we need to do is shift the significand and apply the correct sign.
-        aSignificand >>= @intCast(S, 4 - aExponent);
-        return @bitCast(T, resultSign | aSignificand);
-    }
-
-    // Low three bits are round, guard, and sticky.
-    const roundGuardSticky = aSignificand & 0x7;
-
-    // Shift the significand into place, and mask off the integer bit, if it's implicit.
-    var result = (aSignificand >> 3) & significandMask;
-
-    // Insert the exponent and sign.
-    result |= @intCast(Z, aExponent) << significandBits;
-    result |= resultSign;
-
-    // Final rounding.  The result may overflow to infinity, but that is the
-    // correct result in that case.
-    if (roundGuardSticky > 0x4) result += 1;
-    if (roundGuardSticky == 0x4) result += result & 1;
-
-    // Restore any explicit integer bit, if it was rounded off
-    if (significandBits != fractionalBits) {
-        if ((result >> significandBits) != 0) result |= integerBit;
-    }
-
-    return @bitCast(T, result);
-}
-
-test {
-    _ = @import("addXf3_test.zig");
-}
diff --git a/lib/compiler_rt/addXf3_test.zig b/lib/compiler_rt/addXf3_test.zig
deleted file mode 100644
index f38c9d60185730e85da31e140b5f80f83d09d546..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/addXf3_test.zig
+++ /dev/null
@@ -1,157 +0,0 @@
-// Ported from:
-//
-// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/addtf3_test.c
-// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/subtf3_test.c
-
-const std = @import("std");
-const math = std.math;
-const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
-
-const __addtf3 = @import("addXf3.zig").__addtf3;
-
-fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
-    const x = __addtf3(a, b);
-
-    const rep = @bitCast(u128, x);
-    const hi = @intCast(u64, rep >> 64);
-    const lo = @truncate(u64, rep);
-
-    if (hi == expected_hi and lo == expected_lo) {
-        return;
-    }
-    // test other possible NaN representation (signal NaN)
-    else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
-        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
-            ((hi & 0xffffffffffff) > 0 or lo > 0))
-        {
-            return;
-        }
-    }
-
-    return error.TestFailed;
-}
-
-test "addtf3" {
-    try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
-
-    // NaN + any = NaN
-    try test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
-
-    // inf + inf = inf
-    try test__addtf3(math.inf(f128), math.inf(f128), 0x7fff000000000000, 0x0);
-
-    // inf + any = inf
-    try test__addtf3(math.inf(f128), 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
-
-    // any + any
-    try test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
-    try test__addtf3(0x1.edcba52449872455634654321fp-1, 0x1.23456734245345543849abcdefp+5, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
-}
-
-const __subtf3 = @import("addXf3.zig").__subtf3;
-
-fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
-    const x = __subtf3(a, b);
-
-    const rep = @bitCast(u128, x);
-    const hi = @intCast(u64, rep >> 64);
-    const lo = @truncate(u64, rep);
-
-    if (hi == expected_hi and lo == expected_lo) {
-        return;
-    }
-    // test other possible NaN representation (signal NaN)
-    else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
-        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
-            ((hi & 0xffffffffffff) > 0 or lo > 0))
-        {
-            return;
-        }
-    }
-
-    return error.TestFailed;
-}
-
-test "subtf3" {
-    // qNaN - any = qNaN
-    try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
-
-    // NaN + any = NaN
-    try test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
-
-    // inf - any = inf
-    try test__subtf3(math.inf(f128), 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
-
-    // any + any
-    try test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
-    try test__subtf3(0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x1.234567829a3bcdef5678ade36734p+5, 0xc0041b8af1915166, 0xa44a7bca780a166c);
-}
-
-const __addxf3 = @import("addXf3.zig").__addxf3;
-const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) | (1 << (math.floatFractionalBits(f80) - 1)));
-
-fn test__addxf3(a: f80, b: f80, expected: u80) !void {
-    const x = __addxf3(a, b);
-    const rep = @bitCast(u80, x);
-
-    if (rep == expected)
-        return;
-
-    if (math.isNan(@bitCast(f80, expected)) and math.isNan(x))
-        return; // We don't currently test NaN payload propagation
-
-    return error.TestFailed;
-}
-
-test "addxf3" {
-    // NaN + any = NaN
-    try test__addxf3(qnan80, 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
-    try test__addxf3(@bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
-
-    // any + NaN = NaN
-    try test__addxf3(0x1.23456789abcdefp+5, qnan80, @bitCast(u80, qnan80));
-    try test__addxf3(0x1.23456789abcdefp+5, @bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), @bitCast(u80, qnan80));
-
-    // NaN + inf = NaN
-    try test__addxf3(qnan80, math.inf(f80), @bitCast(u80, qnan80));
-
-    // inf + NaN = NaN
-    try test__addxf3(math.inf(f80), qnan80, @bitCast(u80, qnan80));
-
-    // inf + inf = inf
-    try test__addxf3(math.inf(f80), math.inf(f80), @bitCast(u80, math.inf(f80)));
-
-    // inf + -inf = NaN
-    try test__addxf3(math.inf(f80), -math.inf(f80), @bitCast(u80, qnan80));
-
-    // -inf + inf = NaN
-    try test__addxf3(-math.inf(f80), math.inf(f80), @bitCast(u80, qnan80));
-
-    // inf + any = inf
-    try test__addxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @bitCast(u80, math.inf(f80)));
-
-    // any + inf = inf
-    try test__addxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @bitCast(u80, math.inf(f80)));
-
-    // any + any
-    try test__addxf3(0x1.23456789abcdp+5, 0x1.dcba987654321p+5, 0x4005_BFFFFFFFFFFFC400);
-    try test__addxf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x4004_957E_4AE4_5ABC_B0F3);
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.0p-63, 0x3FFF_FFFFFFFFFFFFFFFF); // exact
-    try test__addxf3(0x1.ffff_ffff_ffff_fffep+0, 0x0.0p0, 0x3FFF_FFFFFFFFFFFFFFFF); // exact
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.4p-63, 0x3FFF_FFFFFFFFFFFFFFFF); // round down
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.8p-63, 0x4000_8000000000000000); // round up to even
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.cp-63, 0x4000_8000000000000000); // round up
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x2.0p-63, 0x4000_8000000000000000); // exact
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x2.1p-63, 0x4000_8000000000000000); // round down
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x3.0p-63, 0x4000_8000000000000000); // round down to even
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x3.1p-63, 0x4000_8000000000000001); // round up
-    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x4.0p-63, 0x4000_8000000000000001); // exact
-
-    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.0p-63, 0x3FFF_8800000000000000); // exact
-    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.7p-63, 0x3FFF_8800000000000000); // round down
-    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.8p-63, 0x3FFF_8800000000000000); // round down to even
-    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.9p-63, 0x3FFF_8800000000000001); // round up
-    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x2.0p-63, 0x3FFF_8800000000000001); // exact
-    try test__addxf3(0x0.ffff_ffff_ffff_fffcp-16382, 0x0.0000_0000_0000_0002p-16382, 0x0000_7FFFFFFFFFFFFFFF); // exact
-    try test__addxf3(0x0.1fff_ffff_ffff_fffcp-16382, 0x0.0000_0000_0000_0002p-16382, 0x0000_0FFFFFFFFFFFFFFF); // exact
-}
diff --git a/lib/compiler_rt/adddf3.zig b/lib/compiler_rt/adddf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1b511f78a4e988dfe6ae453037d3fc187cdff24b
--- /dev/null
+++ b/lib/compiler_rt/adddf3.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const addf3 = @import("./addf3.zig").addf3;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_dadd, .{ .name = "__aeabi_dadd", .linkage = common.linkage });
+    } else {
+        @export(__adddf3, .{ .name = "__adddf3", .linkage = common.linkage });
+    }
+}
+
+fn __adddf3(a: f64, b: f64) callconv(.C) f64 {
+    return addf3(f64, a, b);
+}
+
+fn __aeabi_dadd(a: f64, b: f64) callconv(.AAPCS) f64 {
+    return addf3(f64, a, b);
+}
diff --git a/lib/compiler_rt/addf3.zig b/lib/compiler_rt/addf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7f2e368121b76a8d6acd92ec51175fa1053e987f
--- /dev/null
+++ b/lib/compiler_rt/addf3.zig
@@ -0,0 +1,172 @@
+const std = @import("std");
+const math = std.math;
+const common = @import("./common.zig");
+const normalize = common.normalize;
+
+/// Ported from:
+///
+/// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/lib/builtins/fp_add_impl.inc
+pub inline fn addf3(comptime T: type, a: T, b: T) T {
+    const bits = @typeInfo(T).Float.bits;
+    const Z = std.meta.Int(.unsigned, bits);
+    const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1));
+
+    const typeWidth = bits;
+    const significandBits = math.floatMantissaBits(T);
+    const fractionalBits = math.floatFractionalBits(T);
+    const exponentBits = math.floatExponentBits(T);
+
+    const signBit = (@as(Z, 1) << (significandBits + exponentBits));
+    const maxExponent = ((1 << exponentBits) - 1);
+
+    const integerBit = (@as(Z, 1) << fractionalBits);
+    const quietBit = integerBit >> 1;
+    const significandMask = (@as(Z, 1) << significandBits) - 1;
+
+    const absMask = signBit - 1;
+    const qnanRep = @bitCast(Z, math.nan(T)) | quietBit;
+
+    var aRep = @bitCast(Z, a);
+    var bRep = @bitCast(Z, b);
+    const aAbs = aRep & absMask;
+    const bAbs = bRep & absMask;
+
+    const infRep = @bitCast(Z, math.inf(T));
+
+    // Detect if a or b is zero, infinity, or NaN.
+    if (aAbs -% @as(Z, 1) >= infRep - @as(Z, 1) or
+        bAbs -% @as(Z, 1) >= infRep - @as(Z, 1))
+    {
+        // NaN + anything = qNaN
+        if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
+        // anything + NaN = qNaN
+        if (bAbs > infRep) return @bitCast(T, @bitCast(Z, b) | quietBit);
+
+        if (aAbs == infRep) {
+            // +/-infinity + -/+infinity = qNaN
+            if ((@bitCast(Z, a) ^ @bitCast(Z, b)) == signBit) {
+                return @bitCast(T, qnanRep);
+            }
+            // +/-infinity + anything remaining = +/- infinity
+            else {
+                return a;
+            }
+        }
+
+        // anything remaining + +/-infinity = +/-infinity
+        if (bAbs == infRep) return b;
+
+        // zero + anything = anything
+        if (aAbs == 0) {
+            // but we need to get the sign right for zero + zero
+            if (bAbs == 0) {
+                return @bitCast(T, @bitCast(Z, a) & @bitCast(Z, b));
+            } else {
+                return b;
+            }
+        }
+
+        // anything + zero = anything
+        if (bAbs == 0) return a;
+    }
+
+    // Swap a and b if necessary so that a has the larger absolute value.
+    if (bAbs > aAbs) {
+        const temp = aRep;
+        aRep = bRep;
+        bRep = temp;
+    }
+
+    // Extract the exponent and significand from the (possibly swapped) a and b.
+    var aExponent = @intCast(i32, (aRep >> significandBits) & maxExponent);
+    var bExponent = @intCast(i32, (bRep >> significandBits) & maxExponent);
+    var aSignificand = aRep & significandMask;
+    var bSignificand = bRep & significandMask;
+
+    // Normalize any denormals, and adjust the exponent accordingly.
+    if (aExponent == 0) aExponent = normalize(T, &aSignificand);
+    if (bExponent == 0) bExponent = normalize(T, &bSignificand);
+
+    // The sign of the result is the sign of the larger operand, a.  If they
+    // have opposite signs, we are performing a subtraction; otherwise addition.
+    const resultSign = aRep & signBit;
+    const subtraction = (aRep ^ bRep) & signBit != 0;
+
+    // Shift the significands to give us round, guard and sticky, and or in the
+    // implicit significand bit.  (If we fell through from the denormal path it
+    // was already set by normalize( ), but setting it twice won't hurt
+    // anything.)
+    aSignificand = (aSignificand | integerBit) << 3;
+    bSignificand = (bSignificand | integerBit) << 3;
+
+    // Shift the significand of b by the difference in exponents, with a sticky
+    // bottom bit to get rounding correct.
+    const @"align" = @intCast(u32, aExponent - bExponent);
+    if (@"align" != 0) {
+        if (@"align" < typeWidth) {
+            const sticky = if (bSignificand << @intCast(S, typeWidth - @"align") != 0) @as(Z, 1) else 0;
+            bSignificand = (bSignificand >> @truncate(S, @"align")) | sticky;
+        } else {
+            bSignificand = 1; // sticky; b is known to be non-zero.
+        }
+    }
+    if (subtraction) {
+        aSignificand -= bSignificand;
+        // If a == -b, return +zero.
+        if (aSignificand == 0) return @bitCast(T, @as(Z, 0));
+
+        // If partial cancellation occured, we need to left-shift the result
+        // and adjust the exponent:
+        if (aSignificand < integerBit << 3) {
+            const shift = @intCast(i32, @clz(Z, aSignificand)) - @intCast(i32, @clz(std.meta.Int(.unsigned, bits), integerBit << 3));
+            aSignificand <<= @intCast(S, shift);
+            aExponent -= shift;
+        }
+    } else { // addition
+        aSignificand += bSignificand;
+
+        // If the addition carried up, we need to right-shift the result and
+        // adjust the exponent:
+        if (aSignificand & (integerBit << 4) != 0) {
+            const sticky = aSignificand & 1;
+            aSignificand = aSignificand >> 1 | sticky;
+            aExponent += 1;
+        }
+    }
+
+    // If we have overflowed the type, return +/- infinity:
+    if (aExponent >= maxExponent) return @bitCast(T, infRep | resultSign);
+
+    if (aExponent <= 0) {
+        // Result is denormal; the exponent and round/sticky bits are zero.
+        // All we need to do is shift the significand and apply the correct sign.
+        aSignificand >>= @intCast(S, 4 - aExponent);
+        return @bitCast(T, resultSign | aSignificand);
+    }
+
+    // Low three bits are round, guard, and sticky.
+    const roundGuardSticky = aSignificand & 0x7;
+
+    // Shift the significand into place, and mask off the integer bit, if it's implicit.
+    var result = (aSignificand >> 3) & significandMask;
+
+    // Insert the exponent and sign.
+    result |= @intCast(Z, aExponent) << significandBits;
+    result |= resultSign;
+
+    // Final rounding.  The result may overflow to infinity, but that is the
+    // correct result in that case.
+    if (roundGuardSticky > 0x4) result += 1;
+    if (roundGuardSticky == 0x4) result += result & 1;
+
+    // Restore any explicit integer bit, if it was rounded off
+    if (significandBits != fractionalBits) {
+        if ((result >> significandBits) != 0) result |= integerBit;
+    }
+
+    return @bitCast(T, result);
+}
+
+test {
+    _ = @import("addf3_test.zig");
+}
diff --git a/lib/compiler_rt/addf3_test.zig b/lib/compiler_rt/addf3_test.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cd3f3ab89c9e9d59cd0be6883f3ce5e1d4828c82
--- /dev/null
+++ b/lib/compiler_rt/addf3_test.zig
@@ -0,0 +1,157 @@
+// Ported from:
+//
+// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/addtf3_test.c
+// https://github.com/llvm/llvm-project/blob/02d85149a05cb1f6dc49f0ba7a2ceca53718ae17/compiler-rt/test/builtins/Unit/subtf3_test.c
+
+const std = @import("std");
+const math = std.math;
+const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
+
+const __addtf3 = @import("addf3.zig").__addtf3;
+
+fn test__addtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
+    const x = __addtf3(a, b);
+
+    const rep = @bitCast(u128, x);
+    const hi = @intCast(u64, rep >> 64);
+    const lo = @truncate(u64, rep);
+
+    if (hi == expected_hi and lo == expected_lo) {
+        return;
+    }
+    // test other possible NaN representation (signal NaN)
+    else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
+        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
+            ((hi & 0xffffffffffff) > 0 or lo > 0))
+        {
+            return;
+        }
+    }
+
+    return error.TestFailed;
+}
+
+test "addtf3" {
+    try test__addtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // NaN + any = NaN
+    try test__addtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // inf + inf = inf
+    try test__addtf3(math.inf(f128), math.inf(f128), 0x7fff000000000000, 0x0);
+
+    // inf + any = inf
+    try test__addtf3(math.inf(f128), 0x1.2335653452436234723489432abcdefp+5, 0x7fff000000000000, 0x0);
+
+    // any + any
+    try test__addtf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
+    try test__addtf3(0x1.edcba52449872455634654321fp-1, 0x1.23456734245345543849abcdefp+5, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
+}
+
+const __subtf3 = @import("addf3.zig").__subtf3;
+
+fn test__subtf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
+    const x = __subtf3(a, b);
+
+    const rep = @bitCast(u128, x);
+    const hi = @intCast(u64, rep >> 64);
+    const lo = @truncate(u64, rep);
+
+    if (hi == expected_hi and lo == expected_lo) {
+        return;
+    }
+    // test other possible NaN representation (signal NaN)
+    else if (expected_hi == 0x7fff800000000000 and expected_lo == 0x0) {
+        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
+            ((hi & 0xffffffffffff) > 0 or lo > 0))
+        {
+            return;
+        }
+    }
+
+    return error.TestFailed;
+}
+
+test "subtf3" {
+    // qNaN - any = qNaN
+    try test__subtf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // NaN + any = NaN
+    try test__subtf3(@bitCast(f128, (@as(u128, 0x7fff000000000000) << 64) | @as(u128, 0x800030000000)), 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // inf - any = inf
+    try test__subtf3(math.inf(f128), 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
+
+    // any + any
+    try test__subtf3(0x1.234567829a3bcdef5678ade36734p+5, 0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x40041b8af1915166, 0xa44a7bca780a166c);
+    try test__subtf3(0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x1.234567829a3bcdef5678ade36734p+5, 0xc0041b8af1915166, 0xa44a7bca780a166c);
+}
+
+const __addxf3 = @import("addf3.zig").__addxf3;
+const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) | (1 << (math.floatFractionalBits(f80) - 1)));
+
+fn test__addxf3(a: f80, b: f80, expected: u80) !void {
+    const x = __addxf3(a, b);
+    const rep = @bitCast(u80, x);
+
+    if (rep == expected)
+        return;
+
+    if (math.isNan(@bitCast(f80, expected)) and math.isNan(x))
+        return; // We don't currently test NaN payload propagation
+
+    return error.TestFailed;
+}
+
+test "addxf3" {
+    // NaN + any = NaN
+    try test__addxf3(qnan80, 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
+    try test__addxf3(@bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
+
+    // any + NaN = NaN
+    try test__addxf3(0x1.23456789abcdefp+5, qnan80, @bitCast(u80, qnan80));
+    try test__addxf3(0x1.23456789abcdefp+5, @bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), @bitCast(u80, qnan80));
+
+    // NaN + inf = NaN
+    try test__addxf3(qnan80, math.inf(f80), @bitCast(u80, qnan80));
+
+    // inf + NaN = NaN
+    try test__addxf3(math.inf(f80), qnan80, @bitCast(u80, qnan80));
+
+    // inf + inf = inf
+    try test__addxf3(math.inf(f80), math.inf(f80), @bitCast(u80, math.inf(f80)));
+
+    // inf + -inf = NaN
+    try test__addxf3(math.inf(f80), -math.inf(f80), @bitCast(u80, qnan80));
+
+    // -inf + inf = NaN
+    try test__addxf3(-math.inf(f80), math.inf(f80), @bitCast(u80, qnan80));
+
+    // inf + any = inf
+    try test__addxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @bitCast(u80, math.inf(f80)));
+
+    // any + inf = inf
+    try test__addxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @bitCast(u80, math.inf(f80)));
+
+    // any + any
+    try test__addxf3(0x1.23456789abcdp+5, 0x1.dcba987654321p+5, 0x4005_BFFFFFFFFFFFC400);
+    try test__addxf3(0x1.23456734245345543849abcdefp+5, 0x1.edcba52449872455634654321fp-1, 0x4004_957E_4AE4_5ABC_B0F3);
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.0p-63, 0x3FFF_FFFFFFFFFFFFFFFF); // exact
+    try test__addxf3(0x1.ffff_ffff_ffff_fffep+0, 0x0.0p0, 0x3FFF_FFFFFFFFFFFFFFFF); // exact
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.4p-63, 0x3FFF_FFFFFFFFFFFFFFFF); // round down
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.8p-63, 0x4000_8000000000000000); // round up to even
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x1.cp-63, 0x4000_8000000000000000); // round up
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x2.0p-63, 0x4000_8000000000000000); // exact
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x2.1p-63, 0x4000_8000000000000000); // round down
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x3.0p-63, 0x4000_8000000000000000); // round down to even
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x3.1p-63, 0x4000_8000000000000001); // round up
+    try test__addxf3(0x1.ffff_ffff_ffff_fffcp+0, 0x4.0p-63, 0x4000_8000000000000001); // exact
+
+    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.0p-63, 0x3FFF_8800000000000000); // exact
+    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.7p-63, 0x3FFF_8800000000000000); // round down
+    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.8p-63, 0x3FFF_8800000000000000); // round down to even
+    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x1.9p-63, 0x3FFF_8800000000000001); // round up
+    try test__addxf3(0x1.0fff_ffff_ffff_fffep+0, 0x2.0p-63, 0x3FFF_8800000000000001); // exact
+    try test__addxf3(0x0.ffff_ffff_ffff_fffcp-16382, 0x0.0000_0000_0000_0002p-16382, 0x0000_7FFFFFFFFFFFFFFF); // exact
+    try test__addxf3(0x0.1fff_ffff_ffff_fffcp-16382, 0x0.0000_0000_0000_0002p-16382, 0x0000_0FFFFFFFFFFFFFFF); // exact
+}
diff --git a/lib/compiler_rt/addsf3.zig b/lib/compiler_rt/addsf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..83f8285371bcf1a3f55cddc5df1d28218ab73b13
--- /dev/null
+++ b/lib/compiler_rt/addsf3.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const addf3 = @import("./addf3.zig").addf3;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_fadd, .{ .name = "__aeabi_fadd", .linkage = common.linkage });
+    } else {
+        @export(__addsf3, .{ .name = "__addsf3", .linkage = common.linkage });
+    }
+}
+
+fn __addsf3(a: f32, b: f32) callconv(.C) f32 {
+    return addf3(f32, a, b);
+}
+
+fn __aeabi_fadd(a: f32, b: f32) callconv(.AAPCS) f32 {
+    return addf3(f32, a, b);
+}
diff --git a/lib/compiler_rt/addtf3.zig b/lib/compiler_rt/addtf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..40a6e6c8b752f489b8e8fb56729290ade7a4bc9a
--- /dev/null
+++ b/lib/compiler_rt/addtf3.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const addf3 = @import("./addf3.zig").addf3;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__addkf3, .{ .name = "__addkf3", .linkage = common.linkage });
+    } else {
+        @export(__addtf3, .{ .name = "__addtf3", .linkage = common.linkage });
+    }
+}
+
+fn __addtf3(a: f128, b: f128) callconv(.C) f128 {
+    return addf3(f128, a, b);
+}
+
+fn __addkf3(a: f128, b: f128) callconv(.C) f128 {
+    return addf3(f128, a, b);
+}
diff --git a/lib/compiler_rt/addxf3.zig b/lib/compiler_rt/addxf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..67e7dd849105e8ce731a9d77cbde07f04c57bd9d
--- /dev/null
+++ b/lib/compiler_rt/addxf3.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const addf3 = @import("./addf3.zig").addf3;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__addxf3, .{ .name = "__addxf3", .linkage = common.linkage });
+}
+
+fn __addxf3(a: f80, b: f80) callconv(.C) f80 {
+    return addf3(f80, a, b);
+}
diff --git a/lib/compiler_rt/cmpdf2.zig b/lib/compiler_rt/cmpdf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f1661731fbae09499931e5da2852cff23c068663
--- /dev/null
+++ b/lib/compiler_rt/cmpdf2.zig
@@ -0,0 +1,68 @@
+///! The quoted behavior definitions are from
+///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = common.linkage });
+        @export(__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = common.linkage });
+        @export(__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = common.linkage });
+    } else {
+        @export(__eqdf2, .{ .name = "__eqdf2", .linkage = common.linkage });
+        @export(__nedf2, .{ .name = "__nedf2", .linkage = common.linkage });
+        @export(__ledf2, .{ .name = "__ledf2", .linkage = common.linkage });
+        @export(__cmpdf2, .{ .name = "__cmpdf2", .linkage = common.linkage });
+        @export(__ltdf2, .{ .name = "__ltdf2", .linkage = common.linkage });
+    }
+}
+
+/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
+/// if a is greater than b, they return 1; and if a and b are equal they return 0.
+/// If either argument is NaN they return 1..."
+///
+/// Note that this matches the definition of `__ledf2`, `__eqdf2`, `__nedf2`, `__cmpdf2`,
+/// and `__ltdf2`.
+fn __cmpdf2(a: f64, b: f64) callconv(.C) i32 {
+    return @enumToInt(comparef.cmpf2(f64, comparef.LE, a, b));
+}
+
+/// "These functions return a value less than or equal to zero if neither argument is NaN,
+/// and a is less than or equal to b."
+fn __ledf2(a: f64, b: f64) callconv(.C) i32 {
+    return __cmpdf2(a, b);
+}
+
+/// "These functions return zero if neither argument is NaN, and a and b are equal."
+/// Note that due to some kind of historical accident, __eqdf2 and __nedf2 are defined
+/// to have the same return value.
+fn __eqdf2(a: f64, b: f64) callconv(.C) i32 {
+    return __cmpdf2(a, b);
+}
+
+/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
+/// Note that due to some kind of historical accident, __eqdf2 and __nedf2 are defined
+/// to have the same return value.
+fn __nedf2(a: f64, b: f64) callconv(.C) i32 {
+    return __cmpdf2(a, b);
+}
+
+/// "These functions return a value less than zero if neither argument is NaN, and a
+/// is strictly less than b."
+fn __ltdf2(a: f64, b: f64) callconv(.C) i32 {
+    return __cmpdf2(a, b);
+}
+
+fn __aeabi_dcmpeq(a: f64, b: f64) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f64, comparef.LE, a, b) == .Equal);
+}
+
+fn __aeabi_dcmplt(a: f64, b: f64) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f64, comparef.LE, a, b) == .Less);
+}
+
+fn __aeabi_dcmple(a: f64, b: f64) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f64, comparef.LE, a, b) != .Greater);
+}
diff --git a/lib/compiler_rt/cmpsf2.zig b/lib/compiler_rt/cmpsf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..23be99c3f773157f872aab39538d9d8c31220d80
--- /dev/null
+++ b/lib/compiler_rt/cmpsf2.zig
@@ -0,0 +1,68 @@
+///! The quoted behavior definitions are from
+///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_fcmpeq, .{ .name = "__aeabi_fcmpeq", .linkage = common.linkage });
+        @export(__aeabi_fcmplt, .{ .name = "__aeabi_fcmplt", .linkage = common.linkage });
+        @export(__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = common.linkage });
+    } else {
+        @export(__eqsf2, .{ .name = "__eqsf2", .linkage = common.linkage });
+        @export(__nesf2, .{ .name = "__nesf2", .linkage = common.linkage });
+        @export(__lesf2, .{ .name = "__lesf2", .linkage = common.linkage });
+        @export(__cmpsf2, .{ .name = "__cmpsf2", .linkage = common.linkage });
+        @export(__ltsf2, .{ .name = "__ltsf2", .linkage = common.linkage });
+    }
+}
+
+/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
+/// if a is greater than b, they return 1; and if a and b are equal they return 0.
+/// If either argument is NaN they return 1..."
+///
+/// Note that this matches the definition of `__lesf2`, `__eqsf2`, `__nesf2`, `__cmpsf2`,
+/// and `__ltsf2`.
+fn __cmpsf2(a: f32, b: f32) callconv(.C) i32 {
+    return @enumToInt(comparef.cmpf2(f32, comparef.LE, a, b));
+}
+
+/// "These functions return a value less than or equal to zero if neither argument is NaN,
+/// and a is less than or equal to b."
+fn __lesf2(a: f32, b: f32) callconv(.C) i32 {
+    return __cmpsf2(a, b);
+}
+
+/// "These functions return zero if neither argument is NaN, and a and b are equal."
+/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
+/// to have the same return value.
+fn __eqsf2(a: f32, b: f32) callconv(.C) i32 {
+    return __cmpsf2(a, b);
+}
+
+/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
+/// Note that due to some kind of historical accident, __eqsf2 and __nesf2 are defined
+/// to have the same return value.
+fn __nesf2(a: f32, b: f32) callconv(.C) i32 {
+    return __cmpsf2(a, b);
+}
+
+/// "These functions return a value less than zero if neither argument is NaN, and a
+/// is strictly less than b."
+fn __ltsf2(a: f32, b: f32) callconv(.C) i32 {
+    return __cmpsf2(a, b);
+}
+
+fn __aeabi_fcmpeq(a: f32, b: f32) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f32, comparef.LE, a, b) == .Equal);
+}
+
+fn __aeabi_fcmplt(a: f32, b: f32) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f32, comparef.LE, a, b) == .Less);
+}
+
+fn __aeabi_fcmple(a: f32, b: f32) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f32, comparef.LE, a, b) != .Greater);
+}
diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..86dc68ad56f72bb16fedc6ebac3c0eb6d52ea8e3
--- /dev/null
+++ b/lib/compiler_rt/cmptf2.zig
@@ -0,0 +1,73 @@
+///! The quoted behavior definitions are from
+///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__eqkf2, .{ .name = "__eqkf2", .linkage = common.linkage });
+        @export(__nekf2, .{ .name = "__nekf2", .linkage = common.linkage });
+        @export(__ltkf2, .{ .name = "__ltkf2", .linkage = common.linkage });
+        @export(__lekf2, .{ .name = "__lekf2", .linkage = common.linkage });
+    } else {
+        @export(__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage });
+        @export(__netf2, .{ .name = "__netf2", .linkage = common.linkage });
+        @export(__letf2, .{ .name = "__letf2", .linkage = common.linkage });
+        @export(__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage });
+        @export(__lttf2, .{ .name = "__lttf2", .linkage = common.linkage });
+    }
+}
+
+/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
+/// if a is greater than b, they return 1; and if a and b are equal they return 0.
+/// If either argument is NaN they return 1..."
+///
+/// Note that this matches the definition of `__letf2`, `__eqtf2`, `__netf2`, `__cmptf2`,
+/// and `__lttf2`.
+fn __cmptf2(a: f128, b: f128) callconv(.C) i32 {
+    return @enumToInt(comparef.cmpf2(f128, comparef.LE, a, b));
+}
+
+/// "These functions return a value less than or equal to zero if neither argument is NaN,
+/// and a is less than or equal to b."
+fn __letf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
+
+/// "These functions return zero if neither argument is NaN, and a and b are equal."
+/// Note that due to some kind of historical accident, __eqtf2 and __netf2 are defined
+/// to have the same return value.
+fn __eqtf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
+
+/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
+/// Note that due to some kind of historical accident, __eqtf2 and __netf2 are defined
+/// to have the same return value.
+fn __netf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
+
+/// "These functions return a value less than zero if neither argument is NaN, and a
+/// is strictly less than b."
+fn __lttf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
+
+fn __eqkf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
+
+fn __nekf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
+
+fn __ltkf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
+
+fn __lekf2(a: f128, b: f128) callconv(.C) i32 {
+    return __cmptf2(a, b);
+}
diff --git a/lib/compiler_rt/cmpxf2.zig b/lib/compiler_rt/cmpxf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7286316f99c773d725ce9155a561a8b3bc10e4ba
--- /dev/null
+++ b/lib/compiler_rt/cmpxf2.zig
@@ -0,0 +1,50 @@
+///! The quoted behavior definitions are from
+///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__eqxf2, .{ .name = "__eqxf2", .linkage = common.linkage });
+    @export(__nexf2, .{ .name = "__nexf2", .linkage = common.linkage });
+    @export(__lexf2, .{ .name = "__lexf2", .linkage = common.linkage });
+    @export(__cmpxf2, .{ .name = "__cmpxf2", .linkage = common.linkage });
+    @export(__ltxf2, .{ .name = "__ltxf2", .linkage = common.linkage });
+}
+
+/// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
+/// if a is greater than b, they return 1; and if a and b are equal they return 0.
+/// If either argument is NaN they return 1..."
+///
+/// Note that this matches the definition of `__lexf2`, `__eqxf2`, `__nexf2`, `__cmpxf2`,
+/// and `__ltxf2`.
+fn __cmpxf2(a: f80, b: f80) callconv(.C) i32 {
+    return @enumToInt(comparef.cmp_f80(comparef.LE, a, b));
+}
+
+/// "These functions return a value less than or equal to zero if neither argument is NaN,
+/// and a is less than or equal to b."
+fn __lexf2(a: f80, b: f80) callconv(.C) i32 {
+    return __cmpxf2(a, b);
+}
+
+/// "These functions return zero if neither argument is NaN, and a and b are equal."
+/// Note that due to some kind of historical accident, __eqxf2 and __nexf2 are defined
+/// to have the same return value.
+fn __eqxf2(a: f80, b: f80) callconv(.C) i32 {
+    return __cmpxf2(a, b);
+}
+
+/// "These functions return a nonzero value if either argument is NaN, or if a and b are unequal."
+/// Note that due to some kind of historical accident, __eqxf2 and __nexf2 are defined
+/// to have the same return value.
+fn __nexf2(a: f80, b: f80) callconv(.C) i32 {
+    return __cmpxf2(a, b);
+}
+
+/// "These functions return a value less than zero if neither argument is NaN, and a
+/// is strictly less than b."
+fn __ltxf2(a: f80, b: f80) callconv(.C) i32 {
+    return __cmpxf2(a, b);
+}
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
index 7e9bdf81c88e74214df49c811cde47cbe53883d9..196dc330246bfb3bac143a806f6ad0e68bd922d9 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -3,8 +3,14 @@ const builtin = @import("builtin");
 const math = std.math;
 const is_test = builtin.is_test;
 
+pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
+pub const want_aeabi = builtin.cpu.arch.isARM() or builtin.cpu.arch.isThumb();
+pub const want_ppc_abi = builtin.cpu.arch.isPPC() or builtin.cpu.arch.isPPC64();
+pub const want_msvc_abi = builtin.abi == .msvc;
+pub const want_gnu_abi = builtin.abi.isGnu();
+
 // Avoid dragging in the runtime safety mechanisms into this .o file,
-// unless we're trying to test this file.
+// unless we're trying to test compiler-rt.
 pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
     _ = error_return_trace;
     @setCold(true);
@@ -15,8 +21,13 @@ pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) nore
     }
 }
 
+/// AArch64 is the only ABI (at the moment) to support f16 arguments without the
+/// need for extending them to wider fp types.
+/// TODO remove this; do this type selection in the language rather than
+/// here in compiler-rt.
+pub const F16T = if (builtin.cpu.arch.isAARCH64()) f16 else u16;
+
 pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
-    @setRuntimeSafety(is_test);
     switch (Z) {
         u16 => {
             // 16x16 --> 32 bit multiply
@@ -130,15 +141,11 @@ pub fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
     }
 }
 
-// TODO: restore inline keyword, see: https://github.com/ziglang/zig/issues/2154
 pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeInfo(T).Float.bits)) i32 {
-    const bits = @typeInfo(T).Float.bits;
-    const Z = std.meta.Int(.unsigned, bits);
-    const S = std.meta.Int(.unsigned, bits - @clz(Z, @as(Z, bits) - 1));
-    const fractionalBits = math.floatFractionalBits(T);
-    const integerBit = @as(Z, 1) << fractionalBits;
+    const Z = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
+    const integerBit = @as(Z, 1) << std.math.floatFractionalBits(T);
 
-    const shift = @clz(std.meta.Int(.unsigned, bits), significand.*) - @clz(Z, integerBit);
-    significand.* <<= @intCast(S, shift);
+    const shift = @clz(Z, significand.*) - @clz(Z, integerBit);
+    significand.* <<= @intCast(std.math.Log2Int(Z), shift);
     return @as(i32, 1) - shift;
 }
diff --git a/lib/compiler_rt/compareXf2.zig b/lib/compiler_rt/compareXf2.zig
deleted file mode 100644
index d21a6777e42c46ca73885f07d910ea17a7bf32af..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/compareXf2.zig
+++ /dev/null
@@ -1,440 +0,0 @@
-// Ported from:
-//
-// https://github.com/llvm/llvm-project/commit/d674d96bc56c0f377879d01c9d8dfdaaa7859cdb/compiler-rt/lib/builtins/comparesf2.c
-
-const std = @import("std");
-const builtin = @import("builtin");
-const is_test = builtin.is_test;
-const arch = builtin.cpu.arch;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    @export(__lesf2, .{ .name = "__lesf2", .linkage = linkage });
-    @export(__ledf2, .{ .name = "__ledf2", .linkage = linkage });
-    @export(__letf2, .{ .name = "__letf2", .linkage = linkage });
-    @export(__lexf2, .{ .name = "__lexf2", .linkage = linkage });
-
-    @export(__gesf2, .{ .name = "__gesf2", .linkage = linkage });
-    @export(__gedf2, .{ .name = "__gedf2", .linkage = linkage });
-    @export(__getf2, .{ .name = "__getf2", .linkage = linkage });
-    @export(__gexf2, .{ .name = "__gexf2", .linkage = linkage });
-
-    @export(__eqsf2, .{ .name = "__eqsf2", .linkage = linkage });
-    @export(__eqdf2, .{ .name = "__eqdf2", .linkage = linkage });
-    @export(__eqxf2, .{ .name = "__eqxf2", .linkage = linkage });
-
-    @export(__ltsf2, .{ .name = "__ltsf2", .linkage = linkage });
-    @export(__ltdf2, .{ .name = "__ltdf2", .linkage = linkage });
-    @export(__ltxf2, .{ .name = "__ltxf2", .linkage = linkage });
-
-    @export(__nesf2, .{ .name = "__nesf2", .linkage = linkage });
-    @export(__nedf2, .{ .name = "__nedf2", .linkage = linkage });
-    @export(__nexf2, .{ .name = "__nexf2", .linkage = linkage });
-
-    @export(__gtsf2, .{ .name = "__gtsf2", .linkage = linkage });
-    @export(__gtdf2, .{ .name = "__gtdf2", .linkage = linkage });
-    @export(__gtxf2, .{ .name = "__gtxf2", .linkage = linkage });
-
-    @export(__unordsf2, .{ .name = "__unordsf2", .linkage = linkage });
-    @export(__unorddf2, .{ .name = "__unorddf2", .linkage = linkage });
-    @export(__unordtf2, .{ .name = "__unordtf2", .linkage = linkage });
-
-    if (!is_test) {
-        @export(__cmpsf2, .{ .name = "__cmpsf2", .linkage = linkage });
-        @export(__cmpdf2, .{ .name = "__cmpdf2", .linkage = linkage });
-        @export(__cmptf2, .{ .name = "__cmptf2", .linkage = linkage });
-        @export(__eqtf2, .{ .name = "__eqtf2", .linkage = linkage });
-        @export(__lttf2, .{ .name = "__lttf2", .linkage = linkage });
-        @export(__gttf2, .{ .name = "__gttf2", .linkage = linkage });
-        @export(__netf2, .{ .name = "__netf2", .linkage = linkage });
-
-        if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_fcmpeq, .{ .name = "__aeabi_fcmpeq", .linkage = linkage });
-            @export(__aeabi_fcmplt, .{ .name = "__aeabi_fcmplt", .linkage = linkage });
-            @export(__aeabi_fcmple, .{ .name = "__aeabi_fcmple", .linkage = linkage });
-            @export(__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = linkage });
-            @export(__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = linkage });
-            @export(__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = linkage });
-
-            @export(__aeabi_dcmpeq, .{ .name = "__aeabi_dcmpeq", .linkage = linkage });
-            @export(__aeabi_dcmplt, .{ .name = "__aeabi_dcmplt", .linkage = linkage });
-            @export(__aeabi_dcmple, .{ .name = "__aeabi_dcmple", .linkage = linkage });
-            @export(__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = linkage });
-            @export(__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = linkage });
-            @export(__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = linkage });
-        }
-
-        if (arch.isPPC() or arch.isPPC64()) {
-            @export(__eqkf2, .{ .name = "__eqkf2", .linkage = linkage });
-            @export(__nekf2, .{ .name = "__nekf2", .linkage = linkage });
-            @export(__gekf2, .{ .name = "__gekf2", .linkage = linkage });
-            @export(__ltkf2, .{ .name = "__ltkf2", .linkage = linkage });
-            @export(__lekf2, .{ .name = "__lekf2", .linkage = linkage });
-            @export(__gtkf2, .{ .name = "__gtkf2", .linkage = linkage });
-            @export(__unordkf2, .{ .name = "__unordkf2", .linkage = linkage });
-        }
-    }
-}
-
-const LE = enum(i32) {
-    Less = -1,
-    Equal = 0,
-    Greater = 1,
-
-    const Unordered: LE = .Greater;
-};
-
-const GE = enum(i32) {
-    Less = -1,
-    Equal = 0,
-    Greater = 1,
-
-    const Unordered: GE = .Less;
-};
-
-pub inline fn cmp(comptime T: type, comptime RT: type, a: T, b: T) RT {
-    @setRuntimeSafety(builtin.is_test);
-
-    const bits = @typeInfo(T).Float.bits;
-    const srep_t = std.meta.Int(.signed, bits);
-    const rep_t = std.meta.Int(.unsigned, bits);
-
-    const significandBits = std.math.floatMantissaBits(T);
-    const exponentBits = std.math.floatExponentBits(T);
-    const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
-    const absMask = signBit - 1;
-    const infT = comptime std.math.inf(T);
-    const infRep = @bitCast(rep_t, infT);
-
-    const aInt = @bitCast(srep_t, a);
-    const bInt = @bitCast(srep_t, b);
-    const aAbs = @bitCast(rep_t, aInt) & absMask;
-    const bAbs = @bitCast(rep_t, bInt) & absMask;
-
-    // If either a or b is NaN, they are unordered.
-    if (aAbs > infRep or bAbs > infRep) return RT.Unordered;
-
-    // If a and b are both zeros, they are equal.
-    if ((aAbs | bAbs) == 0) return .Equal;
-
-    // If at least one of a and b is positive, we get the same result comparing
-    // a and b as signed integers as we would with a floating-point compare.
-    if ((aInt & bInt) >= 0) {
-        if (aInt < bInt) {
-            return .Less;
-        } else if (aInt == bInt) {
-            return .Equal;
-        } else return .Greater;
-    } else {
-        // Otherwise, both are negative, so we need to flip the sense of the
-        // comparison to get the correct result.  (This assumes a twos- or ones-
-        // complement integer representation; if integers are represented in a
-        // sign-magnitude representation, then this flip is incorrect).
-        if (aInt > bInt) {
-            return .Less;
-        } else if (aInt == bInt) {
-            return .Equal;
-        } else return .Greater;
-    }
-}
-
-pub inline fn unordcmp(comptime T: type, a: T, b: T) i32 {
-    @setRuntimeSafety(builtin.is_test);
-
-    const rep_t = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
-
-    const significandBits = std.math.floatMantissaBits(T);
-    const exponentBits = std.math.floatExponentBits(T);
-    const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
-    const absMask = signBit - 1;
-    const infRep = @bitCast(rep_t, std.math.inf(T));
-
-    const aAbs: rep_t = @bitCast(rep_t, a) & absMask;
-    const bAbs: rep_t = @bitCast(rep_t, b) & absMask;
-
-    return @boolToInt(aAbs > infRep or bAbs > infRep);
-}
-
-// Comparison between f32
-
-pub fn __lesf2(a: f32, b: f32) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp(f32, LE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __gesf2(a: f32, b: f32) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp(f32, GE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __cmpsf2(a: f32, b: f32) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b });
-}
-
-pub fn __eqsf2(a: f32, b: f32) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b });
-}
-
-pub fn __ltsf2(a: f32, b: f32) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b });
-}
-
-pub fn __nesf2(a: f32, b: f32) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __lesf2, .{ a, b });
-}
-
-pub fn __gtsf2(a: f32, b: f32) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __gesf2, .{ a, b });
-}
-
-// Comparison between f64
-
-pub fn __ledf2(a: f64, b: f64) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp(f64, LE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __gedf2(a: f64, b: f64) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp(f64, GE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __cmpdf2(a: f64, b: f64) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b });
-}
-
-pub fn __eqdf2(a: f64, b: f64) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b });
-}
-
-pub fn __ltdf2(a: f64, b: f64) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b });
-}
-
-pub fn __nedf2(a: f64, b: f64) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __ledf2, .{ a, b });
-}
-
-pub fn __gtdf2(a: f64, b: f64) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __gedf2, .{ a, b });
-}
-
-// Comparison between f80
-
-pub inline fn cmp_f80(comptime RT: type, a: f80, b: f80) RT {
-    const a_rep = std.math.break_f80(a);
-    const b_rep = std.math.break_f80(b);
-    const sig_bits = std.math.floatMantissaBits(f80);
-    const int_bit = 0x8000000000000000;
-    const sign_bit = 0x8000;
-    const special_exp = 0x7FFF;
-
-    // If either a or b is NaN, they are unordered.
-    if ((a_rep.exp & special_exp == special_exp and a_rep.fraction ^ int_bit != 0) or
-        (b_rep.exp & special_exp == special_exp and b_rep.fraction ^ int_bit != 0))
-        return RT.Unordered;
-
-    // If a and b are both zeros, they are equal.
-    if ((a_rep.fraction | b_rep.fraction) | ((a_rep.exp | b_rep.exp) & special_exp) == 0)
-        return .Equal;
-
-    if (@boolToInt(a_rep.exp == b_rep.exp) & @boolToInt(a_rep.fraction == b_rep.fraction) != 0) {
-        return .Equal;
-    } else if (a_rep.exp & sign_bit != b_rep.exp & sign_bit) {
-        // signs are different
-        if (@bitCast(i16, a_rep.exp) < @bitCast(i16, b_rep.exp)) {
-            return .Less;
-        } else {
-            return .Greater;
-        }
-    } else {
-        const a_fraction = a_rep.fraction | (@as(u80, a_rep.exp) << sig_bits);
-        const b_fraction = b_rep.fraction | (@as(u80, b_rep.exp) << sig_bits);
-        if (a_fraction < b_fraction) {
-            return .Less;
-        } else {
-            return .Greater;
-        }
-    }
-}
-
-pub fn __lexf2(a: f80, b: f80) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp_f80(LE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __gexf2(a: f80, b: f80) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp_f80(GE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __eqxf2(a: f80, b: f80) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __lexf2, .{ a, b });
-}
-
-pub fn __ltxf2(a: f80, b: f80) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __lexf2, .{ a, b });
-}
-
-pub fn __nexf2(a: f80, b: f80) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __lexf2, .{ a, b });
-}
-
-pub fn __gtxf2(a: f80, b: f80) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __gexf2, .{ a, b });
-}
-
-// Comparison between f128
-
-pub fn __letf2(a: f128, b: f128) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp(f128, LE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __getf2(a: f128, b: f128) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const float = cmp(f128, GE, a, b);
-    return @bitCast(i32, float);
-}
-
-pub fn __cmptf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __eqtf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __lttf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __netf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __gttf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __getf2, .{ a, b });
-}
-
-pub fn __eqkf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __nekf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __gekf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __getf2, .{ a, b });
-}
-
-pub fn __ltkf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __lekf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __letf2, .{ a, b });
-}
-
-pub fn __gtkf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __getf2, .{ a, b });
-}
-
-// Unordered comparison between f32/f64/f128
-
-pub fn __unordsf2(a: f32, b: f32) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    return unordcmp(f32, a, b);
-}
-
-pub fn __unorddf2(a: f64, b: f64) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    return unordcmp(f64, a, b);
-}
-
-pub fn __unordtf2(a: f128, b: f128) callconv(.C) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    return unordcmp(f128, a, b);
-}
-
-pub fn __unordkf2(a: f128, b: f128) callconv(.C) i32 {
-    return @call(.{ .modifier = .always_inline }, __unordtf2, .{ a, b });
-}
-
-// ARM EABI intrinsics
-
-pub fn __aeabi_fcmpeq(a: f32, b: f32) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __eqsf2, .{ a, b }) == 0);
-}
-
-pub fn __aeabi_fcmplt(a: f32, b: f32) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __ltsf2, .{ a, b }) < 0);
-}
-
-pub fn __aeabi_fcmple(a: f32, b: f32) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __lesf2, .{ a, b }) <= 0);
-}
-
-pub fn __aeabi_fcmpge(a: f32, b: f32) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __gesf2, .{ a, b }) >= 0);
-}
-
-pub fn __aeabi_fcmpgt(a: f32, b: f32) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __gtsf2, .{ a, b }) > 0);
-}
-
-pub fn __aeabi_fcmpun(a: f32, b: f32) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __unordsf2, .{ a, b });
-}
-
-pub fn __aeabi_dcmpeq(a: f64, b: f64) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __eqdf2, .{ a, b }) == 0);
-}
-
-pub fn __aeabi_dcmplt(a: f64, b: f64) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __ltdf2, .{ a, b }) < 0);
-}
-
-pub fn __aeabi_dcmple(a: f64, b: f64) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __ledf2, .{ a, b }) <= 0);
-}
-
-pub fn __aeabi_dcmpge(a: f64, b: f64) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __gedf2, .{ a, b }) >= 0);
-}
-
-pub fn __aeabi_dcmpgt(a: f64, b: f64) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @boolToInt(@call(.{ .modifier = .always_inline }, __gtdf2, .{ a, b }) > 0);
-}
-
-pub fn __aeabi_dcmpun(a: f64, b: f64) callconv(.AAPCS) i32 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __unorddf2, .{ a, b });
-}
-
-test "comparesf2" {
-    _ = @import("comparesf2_test.zig");
-}
-test "comparedf2" {
-    _ = @import("comparedf2_test.zig");
-}
diff --git a/lib/compiler_rt/comparef.zig b/lib/compiler_rt/comparef.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1fb6d2dfa0599bcaf1bb82c2ce0fa8adffadabc7
--- /dev/null
+++ b/lib/compiler_rt/comparef.zig
@@ -0,0 +1,118 @@
+const std = @import("std");
+
+pub const LE = enum(i32) {
+    Less = -1,
+    Equal = 0,
+    Greater = 1,
+
+    const Unordered: LE = .Greater;
+};
+
+pub const GE = enum(i32) {
+    Less = -1,
+    Equal = 0,
+    Greater = 1,
+
+    const Unordered: GE = .Less;
+};
+
+pub inline fn cmpf2(comptime T: type, comptime RT: type, a: T, b: T) RT {
+    const bits = @typeInfo(T).Float.bits;
+    const srep_t = std.meta.Int(.signed, bits);
+    const rep_t = std.meta.Int(.unsigned, bits);
+
+    const significandBits = std.math.floatMantissaBits(T);
+    const exponentBits = std.math.floatExponentBits(T);
+    const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
+    const absMask = signBit - 1;
+    const infT = comptime std.math.inf(T);
+    const infRep = @bitCast(rep_t, infT);
+
+    const aInt = @bitCast(srep_t, a);
+    const bInt = @bitCast(srep_t, b);
+    const aAbs = @bitCast(rep_t, aInt) & absMask;
+    const bAbs = @bitCast(rep_t, bInt) & absMask;
+
+    // If either a or b is NaN, they are unordered.
+    if (aAbs > infRep or bAbs > infRep) return RT.Unordered;
+
+    // If a and b are both zeros, they are equal.
+    if ((aAbs | bAbs) == 0) return .Equal;
+
+    // If at least one of a and b is positive, we get the same result comparing
+    // a and b as signed integers as we would with a floating-point compare.
+    if ((aInt & bInt) >= 0) {
+        if (aInt < bInt) {
+            return .Less;
+        } else if (aInt == bInt) {
+            return .Equal;
+        } else return .Greater;
+    } else {
+        // Otherwise, both are negative, so we need to flip the sense of the
+        // comparison to get the correct result.  (This assumes a twos- or ones-
+        // complement integer representation; if integers are represented in a
+        // sign-magnitude representation, then this flip is incorrect).
+        if (aInt > bInt) {
+            return .Less;
+        } else if (aInt == bInt) {
+            return .Equal;
+        } else return .Greater;
+    }
+}
+
+pub inline fn cmp_f80(comptime RT: type, a: f80, b: f80) RT {
+    const a_rep = std.math.break_f80(a);
+    const b_rep = std.math.break_f80(b);
+    const sig_bits = std.math.floatMantissaBits(f80);
+    const int_bit = 0x8000000000000000;
+    const sign_bit = 0x8000;
+    const special_exp = 0x7FFF;
+
+    // If either a or b is NaN, they are unordered.
+    if ((a_rep.exp & special_exp == special_exp and a_rep.fraction ^ int_bit != 0) or
+        (b_rep.exp & special_exp == special_exp and b_rep.fraction ^ int_bit != 0))
+        return RT.Unordered;
+
+    // If a and b are both zeros, they are equal.
+    if ((a_rep.fraction | b_rep.fraction) | ((a_rep.exp | b_rep.exp) & special_exp) == 0)
+        return .Equal;
+
+    if (@boolToInt(a_rep.exp == b_rep.exp) & @boolToInt(a_rep.fraction == b_rep.fraction) != 0) {
+        return .Equal;
+    } else if (a_rep.exp & sign_bit != b_rep.exp & sign_bit) {
+        // signs are different
+        if (@bitCast(i16, a_rep.exp) < @bitCast(i16, b_rep.exp)) {
+            return .Less;
+        } else {
+            return .Greater;
+        }
+    } else {
+        const a_fraction = a_rep.fraction | (@as(u80, a_rep.exp) << sig_bits);
+        const b_fraction = b_rep.fraction | (@as(u80, b_rep.exp) << sig_bits);
+        if (a_fraction < b_fraction) {
+            return .Less;
+        } else {
+            return .Greater;
+        }
+    }
+}
+
+pub inline fn unordcmp(comptime T: type, a: T, b: T) i32 {
+    const rep_t = std.meta.Int(.unsigned, @typeInfo(T).Float.bits);
+
+    const significandBits = std.math.floatMantissaBits(T);
+    const exponentBits = std.math.floatExponentBits(T);
+    const signBit = (@as(rep_t, 1) << (significandBits + exponentBits));
+    const absMask = signBit - 1;
+    const infRep = @bitCast(rep_t, std.math.inf(T));
+
+    const aAbs: rep_t = @bitCast(rep_t, a) & absMask;
+    const bAbs: rep_t = @bitCast(rep_t, b) & absMask;
+
+    return @boolToInt(aAbs > infRep or bAbs > infRep);
+}
+
+test {
+    _ = @import("comparesf2_test.zig");
+    _ = @import("comparedf2_test.zig");
+}
diff --git a/lib/compiler_rt/extendXfYf2.zig b/lib/compiler_rt/extendXfYf2.zig
deleted file mode 100644
index bb21e5f681fa990ef135d37062c35144a0e9fd36..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/extendXfYf2.zig
+++ /dev/null
@@ -1,148 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const is_test = builtin.is_test;
-const arch = builtin.cpu.arch;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = linkage });
-    @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = linkage });
-    @export(__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = linkage });
-    @export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = linkage });
-    @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = linkage });
-
-    if (!is_test) {
-        @export(__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = linkage });
-
-        if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = linkage });
-            @export(__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = linkage });
-        }
-
-        if (arch.isPPC() or arch.isPPC64()) {
-            @export(__extendsfkf2, .{ .name = "__extendsfkf2", .linkage = linkage });
-            @export(__extenddfkf2, .{ .name = "__extenddfkf2", .linkage = linkage });
-        }
-    }
-}
-
-pub fn __extendsfdf2(a: f32) callconv(.C) f64 {
-    return extendXfYf2(f64, f32, @bitCast(u32, a));
-}
-
-pub fn __extenddftf2(a: f64) callconv(.C) f128 {
-    return extendXfYf2(f128, f64, @bitCast(u64, a));
-}
-
-pub fn __extenddfkf2(a: f64) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __extenddftf2, .{a});
-}
-
-pub fn __extendsftf2(a: f32) callconv(.C) f128 {
-    return extendXfYf2(f128, f32, @bitCast(u32, a));
-}
-
-pub fn __extendsfkf2(a: f32) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __extendsftf2, .{a});
-}
-
-// AArch64 is the only ABI (at the moment) to support f16 arguments without the
-// need for extending them to wider fp types.
-pub const F16T = if (arch.isAARCH64()) f16 else u16;
-
-pub fn __extendhfsf2(a: F16T) callconv(.C) f32 {
-    return extendXfYf2(f32, f16, @bitCast(u16, a));
-}
-
-pub fn __gnu_h2f_ieee(a: F16T) callconv(.C) f32 {
-    return @call(.{ .modifier = .always_inline }, __extendhfsf2, .{a});
-}
-
-pub fn __extendhftf2(a: F16T) callconv(.C) f128 {
-    return extendXfYf2(f128, f16, @bitCast(u16, a));
-}
-
-pub fn __aeabi_h2f(arg: u16) callconv(.AAPCS) f32 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, extendXfYf2, .{ f32, f16, arg });
-}
-
-pub fn __aeabi_f2d(arg: f32) callconv(.AAPCS) f64 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, extendXfYf2, .{ f64, f32, @bitCast(u32, arg) });
-}
-
-inline fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits)) dst_t {
-    @setRuntimeSafety(builtin.is_test);
-
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits);
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
-    const srcSigBits = std.math.floatMantissaBits(src_t);
-    const dstSigBits = std.math.floatMantissaBits(dst_t);
-    const DstShift = std.math.Log2Int(dst_rep_t);
-
-    // Various constants whose values follow from the type parameters.
-    // Any reasonable optimizer will fold and propagate all of these.
-    const srcBits = @bitSizeOf(src_t);
-    const srcExpBits = srcBits - srcSigBits - 1;
-    const srcInfExp = (1 << srcExpBits) - 1;
-    const srcExpBias = srcInfExp >> 1;
-
-    const srcMinNormal = 1 << srcSigBits;
-    const srcInfinity = srcInfExp << srcSigBits;
-    const srcSignMask = 1 << (srcSigBits + srcExpBits);
-    const srcAbsMask = srcSignMask - 1;
-    const srcQNaN = 1 << (srcSigBits - 1);
-    const srcNaNCode = srcQNaN - 1;
-
-    const dstBits = @bitSizeOf(dst_t);
-    const dstExpBits = dstBits - dstSigBits - 1;
-    const dstInfExp = (1 << dstExpBits) - 1;
-    const dstExpBias = dstInfExp >> 1;
-
-    const dstMinNormal: dst_rep_t = @as(dst_rep_t, 1) << dstSigBits;
-
-    // Break a into a sign and representation of the absolute value
-    const aRep: src_rep_t = @bitCast(src_rep_t, a);
-    const aAbs: src_rep_t = aRep & srcAbsMask;
-    const sign: src_rep_t = aRep & srcSignMask;
-    var absResult: dst_rep_t = undefined;
-
-    if (aAbs -% srcMinNormal < srcInfinity - srcMinNormal) {
-        // a is a normal number.
-        // Extend to the destination type by shifting the significand and
-        // exponent into the proper position and rebiasing the exponent.
-        absResult = @as(dst_rep_t, aAbs) << (dstSigBits - srcSigBits);
-        absResult += (dstExpBias - srcExpBias) << dstSigBits;
-    } else if (aAbs >= srcInfinity) {
-        // a is NaN or infinity.
-        // Conjure the result by beginning with infinity, then setting the qNaN
-        // bit (if needed) and right-aligning the rest of the trailing NaN
-        // payload field.
-        absResult = dstInfExp << dstSigBits;
-        absResult |= @as(dst_rep_t, aAbs & srcQNaN) << (dstSigBits - srcSigBits);
-        absResult |= @as(dst_rep_t, aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
-    } else if (aAbs != 0) {
-        // a is denormal.
-        // renormalize the significand and clear the leading bit, then insert
-        // the correct adjusted exponent in the destination type.
-        const scale: u32 = @clz(src_rep_t, aAbs) -
-            @clz(src_rep_t, @as(src_rep_t, srcMinNormal));
-        absResult = @as(dst_rep_t, aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
-        absResult ^= dstMinNormal;
-        const resultExponent: u32 = dstExpBias - srcExpBias - scale + 1;
-        absResult |= @intCast(dst_rep_t, resultExponent) << dstSigBits;
-    } else {
-        // a is zero.
-        absResult = 0;
-    }
-
-    // Apply the signbit to (dst_t)abs(a).
-    const result: dst_rep_t align(@alignOf(dst_t)) = absResult | @as(dst_rep_t, sign) << (dstBits - srcBits);
-    return @bitCast(dst_t, result);
-}
-
-test {
-    _ = @import("extendXfYf2_test.zig");
-}
diff --git a/lib/compiler_rt/extend_f80.zig b/lib/compiler_rt/extend_f80.zig
deleted file mode 100644
index fe5a38fc68bc8b2c7c5b259cfce8c414a5e50c67..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/extend_f80.zig
+++ /dev/null
@@ -1,140 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const is_test = builtin.is_test;
-const arch = builtin.cpu.arch;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    @export(__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = linkage });
-    @export(__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = linkage });
-    @export(__extenddfxf2, .{ .name = "__extenddfxf2", .linkage = linkage });
-    @export(__extendxftf2, .{ .name = "__extendxftf2", .linkage = linkage });
-}
-
-// AArch64 is the only ABI (at the moment) to support f16 arguments without the
-// need for extending them to wider fp types.
-const F16T = if (arch.isAARCH64()) f16 else u16;
-
-fn __extendhfxf2(a: F16T) callconv(.C) f80 {
-    return extendF80(f16, @bitCast(u16, a));
-}
-
-fn __extendsfxf2(a: f32) callconv(.C) f80 {
-    return extendF80(f32, @bitCast(u32, a));
-}
-
-fn __extenddfxf2(a: f64) callconv(.C) f80 {
-    return extendF80(f64, @bitCast(u64, a));
-}
-
-inline fn extendF80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits)) f80 {
-    @setRuntimeSafety(builtin.is_test);
-
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits);
-    const src_sig_bits = std.math.floatMantissaBits(src_t);
-    const dst_int_bit = 0x8000000000000000;
-    const dst_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
-
-    const dst_exp_bias = 16383;
-
-    const src_bits = @bitSizeOf(src_t);
-    const src_exp_bits = src_bits - src_sig_bits - 1;
-    const src_inf_exp = (1 << src_exp_bits) - 1;
-    const src_exp_bias = src_inf_exp >> 1;
-
-    const src_min_normal = 1 << src_sig_bits;
-    const src_inf = src_inf_exp << src_sig_bits;
-    const src_sign_mask = 1 << (src_sig_bits + src_exp_bits);
-    const src_abs_mask = src_sign_mask - 1;
-    const src_qnan = 1 << (src_sig_bits - 1);
-    const src_nan_code = src_qnan - 1;
-
-    var dst: std.math.F80 = undefined;
-
-    // Break a into a sign and representation of the absolute value
-    const a_abs = a & src_abs_mask;
-    const sign: u16 = if (a & src_sign_mask != 0) 0x8000 else 0;
-
-    if (a_abs -% src_min_normal < src_inf - src_min_normal) {
-        // a is a normal number.
-        // Extend to the destination type by shifting the significand and
-        // exponent into the proper position and rebiasing the exponent.
-        dst.exp = @intCast(u16, a_abs >> src_sig_bits);
-        dst.exp += dst_exp_bias - src_exp_bias;
-        dst.fraction = @as(u64, a_abs) << (dst_sig_bits - src_sig_bits);
-        dst.fraction |= dst_int_bit; // bit 64 is always set for normal numbers
-    } else if (a_abs >= src_inf) {
-        // a is NaN or infinity.
-        // Conjure the result by beginning with infinity, then setting the qNaN
-        // bit (if needed) and right-aligning the rest of the trailing NaN
-        // payload field.
-        dst.exp = 0x7fff;
-        dst.fraction = dst_int_bit;
-        dst.fraction |= @as(u64, a_abs & src_qnan) << (dst_sig_bits - src_sig_bits);
-        dst.fraction |= @as(u64, a_abs & src_nan_code) << (dst_sig_bits - src_sig_bits);
-    } else if (a_abs != 0) {
-        // a is denormal.
-        // renormalize the significand and clear the leading bit, then insert
-        // the correct adjusted exponent in the destination type.
-        const scale: u16 = @clz(src_rep_t, a_abs) -
-            @clz(src_rep_t, @as(src_rep_t, src_min_normal));
-
-        dst.fraction = @as(u64, a_abs) << @intCast(u6, dst_sig_bits - src_sig_bits + scale);
-        dst.fraction |= dst_int_bit; // bit 64 is always set for normal numbers
-        dst.exp = @truncate(u16, a_abs >> @intCast(u4, src_sig_bits - scale));
-        dst.exp ^= 1;
-        dst.exp |= dst_exp_bias - src_exp_bias - scale + 1;
-    } else {
-        // a is zero.
-        dst.exp = 0;
-        dst.fraction = 0;
-    }
-
-    dst.exp |= sign;
-    return std.math.make_f80(dst);
-}
-
-fn __extendxftf2(a: f80) callconv(.C) f128 {
-    @setRuntimeSafety(builtin.is_test);
-
-    const src_int_bit: u64 = 0x8000000000000000;
-    const src_sig_mask = ~src_int_bit;
-    const src_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
-    const dst_sig_bits = std.math.floatMantissaBits(f128);
-
-    const dst_bits = @bitSizeOf(f128);
-
-    const dst_min_normal = @as(u128, 1) << dst_sig_bits;
-
-    // Break a into a sign and representation of the absolute value
-    var a_rep = std.math.break_f80(a);
-    const sign = a_rep.exp & 0x8000;
-    a_rep.exp &= 0x7FFF;
-    var abs_result: u128 = undefined;
-
-    if (a_rep.exp == 0 and a_rep.fraction == 0) {
-        // zero
-        abs_result = 0;
-    } else if (a_rep.exp == 0x7FFF) {
-        // a is nan or infinite
-        abs_result = @as(u128, a_rep.fraction) << (dst_sig_bits - src_sig_bits);
-        abs_result |= @as(u128, a_rep.exp) << dst_sig_bits;
-    } else if (a_rep.fraction & src_int_bit != 0) {
-        // a is a normal value
-        abs_result = @as(u128, a_rep.fraction & src_sig_mask) << (dst_sig_bits - src_sig_bits);
-        abs_result |= @as(u128, a_rep.exp) << dst_sig_bits;
-    } else {
-        // a is denormal
-        // renormalize the significand and clear the leading bit and integer part,
-        // then insert the correct adjusted exponent in the destination type.
-        const scale: u32 = @clz(u64, a_rep.fraction);
-        abs_result = @as(u128, a_rep.fraction) << @intCast(u7, dst_sig_bits - src_sig_bits + scale + 1);
-        abs_result ^= dst_min_normal;
-        abs_result |= @as(u128, scale + 1) << dst_sig_bits;
-    }
-
-    // Apply the signbit to (dst_t)abs(a).
-    const result: u128 align(@alignOf(f128)) = abs_result | @as(u128, sign) << (dst_bits - 16);
-    return @bitCast(f128, result);
-}
diff --git a/lib/compiler_rt/extenddftf2.zig b/lib/compiler_rt/extenddftf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c957d64a63f4432183aa61af31bcff3f9493296b
--- /dev/null
+++ b/lib/compiler_rt/extenddftf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const extendf = @import("./extendf.zig").extendf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__extenddfkf2, .{ .name = "__extenddfkf2", .linkage = common.linkage });
+    } else {
+        @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage });
+    }
+}
+
+fn __extenddftf2(a: f64) callconv(.C) f128 {
+    return extendf(f128, f64, @bitCast(u64, a));
+}
+
+fn __extenddfkf2(a: f64) callconv(.C) f128 {
+    return extendf(f128, f64, @bitCast(u64, a));
+}
diff --git a/lib/compiler_rt/extenddfxf2.zig b/lib/compiler_rt/extenddfxf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e76b2fc0380aa0b848b5db62899aa2cf83b70175
--- /dev/null
+++ b/lib/compiler_rt/extenddfxf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const extend_f80 = @import("./extendf.zig").extend_f80;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__extenddfxf2, .{ .name = "__extenddfxf2", .linkage = common.linkage });
+}
+
+fn __extenddfxf2(a: f64) callconv(.C) f80 {
+    return extend_f80(f64, @bitCast(u64, a));
+}
diff --git a/lib/compiler_rt/extendf.zig b/lib/compiler_rt/extendf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..15fa1ce0e820036fd7d809457c86da237d895fe5
--- /dev/null
+++ b/lib/compiler_rt/extendf.zig
@@ -0,0 +1,142 @@
+const std = @import("std");
+
+pub inline fn extendf(
+    comptime dst_t: type,
+    comptime src_t: type,
+    a: std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits),
+) dst_t {
+    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits);
+    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
+    const srcSigBits = std.math.floatMantissaBits(src_t);
+    const dstSigBits = std.math.floatMantissaBits(dst_t);
+    const DstShift = std.math.Log2Int(dst_rep_t);
+
+    // Various constants whose values follow from the type parameters.
+    // Any reasonable optimizer will fold and propagate all of these.
+    const srcBits = @bitSizeOf(src_t);
+    const srcExpBits = srcBits - srcSigBits - 1;
+    const srcInfExp = (1 << srcExpBits) - 1;
+    const srcExpBias = srcInfExp >> 1;
+
+    const srcMinNormal = 1 << srcSigBits;
+    const srcInfinity = srcInfExp << srcSigBits;
+    const srcSignMask = 1 << (srcSigBits + srcExpBits);
+    const srcAbsMask = srcSignMask - 1;
+    const srcQNaN = 1 << (srcSigBits - 1);
+    const srcNaNCode = srcQNaN - 1;
+
+    const dstBits = @bitSizeOf(dst_t);
+    const dstExpBits = dstBits - dstSigBits - 1;
+    const dstInfExp = (1 << dstExpBits) - 1;
+    const dstExpBias = dstInfExp >> 1;
+
+    const dstMinNormal: dst_rep_t = @as(dst_rep_t, 1) << dstSigBits;
+
+    // Break a into a sign and representation of the absolute value
+    const aRep: src_rep_t = @bitCast(src_rep_t, a);
+    const aAbs: src_rep_t = aRep & srcAbsMask;
+    const sign: src_rep_t = aRep & srcSignMask;
+    var absResult: dst_rep_t = undefined;
+
+    if (aAbs -% srcMinNormal < srcInfinity - srcMinNormal) {
+        // a is a normal number.
+        // Extend to the destination type by shifting the significand and
+        // exponent into the proper position and rebiasing the exponent.
+        absResult = @as(dst_rep_t, aAbs) << (dstSigBits - srcSigBits);
+        absResult += (dstExpBias - srcExpBias) << dstSigBits;
+    } else if (aAbs >= srcInfinity) {
+        // a is NaN or infinity.
+        // Conjure the result by beginning with infinity, then setting the qNaN
+        // bit (if needed) and right-aligning the rest of the trailing NaN
+        // payload field.
+        absResult = dstInfExp << dstSigBits;
+        absResult |= @as(dst_rep_t, aAbs & srcQNaN) << (dstSigBits - srcSigBits);
+        absResult |= @as(dst_rep_t, aAbs & srcNaNCode) << (dstSigBits - srcSigBits);
+    } else if (aAbs != 0) {
+        // a is denormal.
+        // renormalize the significand and clear the leading bit, then insert
+        // the correct adjusted exponent in the destination type.
+        const scale: u32 = @clz(src_rep_t, aAbs) -
+            @clz(src_rep_t, @as(src_rep_t, srcMinNormal));
+        absResult = @as(dst_rep_t, aAbs) << @intCast(DstShift, dstSigBits - srcSigBits + scale);
+        absResult ^= dstMinNormal;
+        const resultExponent: u32 = dstExpBias - srcExpBias - scale + 1;
+        absResult |= @intCast(dst_rep_t, resultExponent) << dstSigBits;
+    } else {
+        // a is zero.
+        absResult = 0;
+    }
+
+    // Apply the signbit to (dst_t)abs(a).
+    const result: dst_rep_t align(@alignOf(dst_t)) = absResult | @as(dst_rep_t, sign) << (dstBits - srcBits);
+    return @bitCast(dst_t, result);
+}
+
+pub inline fn extend_f80(comptime src_t: type, a: std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits)) f80 {
+    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits);
+    const src_sig_bits = std.math.floatMantissaBits(src_t);
+    const dst_int_bit = 0x8000000000000000;
+    const dst_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
+
+    const dst_exp_bias = 16383;
+
+    const src_bits = @bitSizeOf(src_t);
+    const src_exp_bits = src_bits - src_sig_bits - 1;
+    const src_inf_exp = (1 << src_exp_bits) - 1;
+    const src_exp_bias = src_inf_exp >> 1;
+
+    const src_min_normal = 1 << src_sig_bits;
+    const src_inf = src_inf_exp << src_sig_bits;
+    const src_sign_mask = 1 << (src_sig_bits + src_exp_bits);
+    const src_abs_mask = src_sign_mask - 1;
+    const src_qnan = 1 << (src_sig_bits - 1);
+    const src_nan_code = src_qnan - 1;
+
+    var dst: std.math.F80 = undefined;
+
+    // Break a into a sign and representation of the absolute value
+    const a_abs = a & src_abs_mask;
+    const sign: u16 = if (a & src_sign_mask != 0) 0x8000 else 0;
+
+    if (a_abs -% src_min_normal < src_inf - src_min_normal) {
+        // a is a normal number.
+        // Extend to the destination type by shifting the significand and
+        // exponent into the proper position and rebiasing the exponent.
+        dst.exp = @intCast(u16, a_abs >> src_sig_bits);
+        dst.exp += dst_exp_bias - src_exp_bias;
+        dst.fraction = @as(u64, a_abs) << (dst_sig_bits - src_sig_bits);
+        dst.fraction |= dst_int_bit; // bit 64 is always set for normal numbers
+    } else if (a_abs >= src_inf) {
+        // a is NaN or infinity.
+        // Conjure the result by beginning with infinity, then setting the qNaN
+        // bit (if needed) and right-aligning the rest of the trailing NaN
+        // payload field.
+        dst.exp = 0x7fff;
+        dst.fraction = dst_int_bit;
+        dst.fraction |= @as(u64, a_abs & src_qnan) << (dst_sig_bits - src_sig_bits);
+        dst.fraction |= @as(u64, a_abs & src_nan_code) << (dst_sig_bits - src_sig_bits);
+    } else if (a_abs != 0) {
+        // a is denormal.
+        // renormalize the significand and clear the leading bit, then insert
+        // the correct adjusted exponent in the destination type.
+        const scale: u16 = @clz(src_rep_t, a_abs) -
+            @clz(src_rep_t, @as(src_rep_t, src_min_normal));
+
+        dst.fraction = @as(u64, a_abs) << @intCast(u6, dst_sig_bits - src_sig_bits + scale);
+        dst.fraction |= dst_int_bit; // bit 64 is always set for normal numbers
+        dst.exp = @truncate(u16, a_abs >> @intCast(u4, src_sig_bits - scale));
+        dst.exp ^= 1;
+        dst.exp |= dst_exp_bias - src_exp_bias - scale + 1;
+    } else {
+        // a is zero.
+        dst.exp = 0;
+        dst.fraction = 0;
+    }
+
+    dst.exp |= sign;
+    return std.math.make_f80(dst);
+}
+
+test {
+    _ = @import("extendXfYf2_test.zig");
+}
diff --git a/lib/compiler_rt/extendhfsf2.zig b/lib/compiler_rt/extendhfsf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6ad4ff37df9975d5e483dfad0ae3622078445c8b
--- /dev/null
+++ b/lib/compiler_rt/extendhfsf2.zig
@@ -0,0 +1,26 @@
+const common = @import("./common.zig");
+const extendf = @import("./extendf.zig").extendf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_gnu_abi) {
+        @export(__gnu_h2f_ieee, .{ .name = "__gnu_h2f_ieee", .linkage = common.linkage });
+    } else if (common.want_aeabi) {
+        @export(__aeabi_h2f, .{ .name = "__aeabi_h2f", .linkage = common.linkage });
+    } else {
+        @export(__extendhfsf2, .{ .name = "__extendhfsf2", .linkage = common.linkage });
+    }
+}
+
+fn __extendhfsf2(a: common.F16T) callconv(.C) f32 {
+    return extendf(f32, f16, @bitCast(u16, a));
+}
+
+fn __gnu_h2f_ieee(a: common.F16T) callconv(.C) f32 {
+    return extendf(f32, f16, @bitCast(u16, a));
+}
+
+fn __aeabi_h2f(a: u16) callconv(.AAPCS) f32 {
+    return extendf(f32, f16, @bitCast(u16, a));
+}
diff --git a/lib/compiler_rt/extendhftf2.zig b/lib/compiler_rt/extendhftf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a0c8eb5a1e9635db30ac7a002881b6b5624b3009
--- /dev/null
+++ b/lib/compiler_rt/extendhftf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const extendf = @import("./extendf.zig").extendf;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__extendhftf2, .{ .name = "__extendhftf2", .linkage = common.linkage });
+}
+
+fn __extendhftf2(a: common.F16T) callconv(.C) f128 {
+    return extendf(f128, f16, @bitCast(u16, a));
+}
diff --git a/lib/compiler_rt/extendhfxf2.zig b/lib/compiler_rt/extendhfxf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..e509f965756008e97a3e3edef4d66f2dcebcb2c8
--- /dev/null
+++ b/lib/compiler_rt/extendhfxf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const extend_f80 = @import("./extendf.zig").extend_f80;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__extendhfxf2, .{ .name = "__extendhfxf2", .linkage = common.linkage });
+}
+
+fn __extendhfxf2(a: common.F16T) callconv(.C) f80 {
+    return extend_f80(f16, @bitCast(u16, a));
+}
diff --git a/lib/compiler_rt/extendsfdf2.zig b/lib/compiler_rt/extendsfdf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7fd69f6c2252fce7e02def549306590f161c0d43
--- /dev/null
+++ b/lib/compiler_rt/extendsfdf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const extendf = @import("./extendf.zig").extendf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_f2d, .{ .name = "__aeabi_f2d", .linkage = common.linkage });
+    } else {
+        @export(__extendsfdf2, .{ .name = "__extendsfdf2", .linkage = common.linkage });
+    }
+}
+
+fn __extendsfdf2(a: f32) callconv(.C) f64 {
+    return extendf(f64, f32, @bitCast(u32, a));
+}
+
+fn __aeabi_f2d(a: f32) callconv(.AAPCS) f64 {
+    return extendf(f64, f32, @bitCast(u32, a));
+}
diff --git a/lib/compiler_rt/extendsftf2.zig b/lib/compiler_rt/extendsftf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8b496783c8593e322f7c410dbaeaf0ecba50a779
--- /dev/null
+++ b/lib/compiler_rt/extendsftf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const extendf = @import("./extendf.zig").extendf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__extendsfkf2, .{ .name = "__extendsfkf2", .linkage = common.linkage });
+    } else {
+        @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = common.linkage });
+    }
+}
+
+fn __extendsftf2(a: f32) callconv(.C) f128 {
+    return extendf(f128, f32, @bitCast(u32, a));
+}
+
+fn __extendsfkf2(a: f32) callconv(.C) f128 {
+    return extendf(f128, f32, @bitCast(u32, a));
+}
diff --git a/lib/compiler_rt/extendsfxf2.zig b/lib/compiler_rt/extendsfxf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..41bb5ace852aab7bc603e4ca085f768ff7b1d410
--- /dev/null
+++ b/lib/compiler_rt/extendsfxf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const extend_f80 = @import("./extendf.zig").extend_f80;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__extendsfxf2, .{ .name = "__extendsfxf2", .linkage = common.linkage });
+}
+
+fn __extendsfxf2(a: f32) callconv(.C) f80 {
+    return extend_f80(f32, @bitCast(u32, a));
+}
diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bb5d6a377bd5106200191b0d49f7eeb2e83a2695
--- /dev/null
+++ b/lib/compiler_rt/extendxftf2.zig
@@ -0,0 +1,50 @@
+const std = @import("std");
+const common = @import("./common.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__extendxftf2, .{ .name = "__extendxftf2", .linkage = common.linkage });
+}
+
+fn __extendxftf2(a: f80) callconv(.C) f128 {
+    const src_int_bit: u64 = 0x8000000000000000;
+    const src_sig_mask = ~src_int_bit;
+    const src_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
+    const dst_sig_bits = std.math.floatMantissaBits(f128);
+
+    const dst_bits = @bitSizeOf(f128);
+
+    const dst_min_normal = @as(u128, 1) << dst_sig_bits;
+
+    // Break a into a sign and representation of the absolute value
+    var a_rep = std.math.break_f80(a);
+    const sign = a_rep.exp & 0x8000;
+    a_rep.exp &= 0x7FFF;
+    var abs_result: u128 = undefined;
+
+    if (a_rep.exp == 0 and a_rep.fraction == 0) {
+        // zero
+        abs_result = 0;
+    } else if (a_rep.exp == 0x7FFF) {
+        // a is nan or infinite
+        abs_result = @as(u128, a_rep.fraction) << (dst_sig_bits - src_sig_bits);
+        abs_result |= @as(u128, a_rep.exp) << dst_sig_bits;
+    } else if (a_rep.fraction & src_int_bit != 0) {
+        // a is a normal value
+        abs_result = @as(u128, a_rep.fraction & src_sig_mask) << (dst_sig_bits - src_sig_bits);
+        abs_result |= @as(u128, a_rep.exp) << dst_sig_bits;
+    } else {
+        // a is denormal
+        // renormalize the significand and clear the leading bit and integer part,
+        // then insert the correct adjusted exponent in the destination type.
+        const scale: u32 = @clz(u64, a_rep.fraction);
+        abs_result = @as(u128, a_rep.fraction) << @intCast(u7, dst_sig_bits - src_sig_bits + scale + 1);
+        abs_result ^= dst_min_normal;
+        abs_result |= @as(u128, scale + 1) << dst_sig_bits;
+    }
+
+    // Apply the signbit to (dst_t)abs(a).
+    const result: u128 align(@alignOf(f128)) = abs_result | @as(u128, sign) << (dst_bits - 16);
+    return @bitCast(f128, result);
+}
diff --git a/lib/compiler_rt/fixXfYi.zig b/lib/compiler_rt/fixXfYi.zig
deleted file mode 100644
index c568bba366fac945b1050a73f22454f0e3556d72..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/fixXfYi.zig
+++ /dev/null
@@ -1,312 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const math = std.math;
-const Log2Int = math.Log2Int;
-const arch = builtin.cpu.arch;
-const is_test = builtin.is_test;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    // Float -> Integral Conversion
-
-    // Conversion from f32
-    @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = linkage });
-    @export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = linkage });
-
-    @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = linkage });
-    @export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = linkage });
-
-    @export(__fixsfti, .{ .name = "__fixsfti", .linkage = linkage });
-    @export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = linkage });
-
-    // Conversion from f64
-    @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = linkage });
-    @export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = linkage });
-
-    @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = linkage });
-    @export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = linkage });
-
-    @export(__fixdfti, .{ .name = "__fixdfti", .linkage = linkage });
-    @export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = linkage });
-
-    // Conversion from f80
-    @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = linkage });
-    @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = linkage });
-
-    @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = linkage });
-    @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = linkage });
-
-    @export(__fixxfti, .{ .name = "__fixxfti", .linkage = linkage });
-    @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = linkage });
-
-    // Conversion from f128
-    @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = linkage });
-    @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = linkage });
-
-    @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = linkage });
-    @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = linkage });
-
-    @export(__fixtfti, .{ .name = "__fixtfti", .linkage = linkage });
-    @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = linkage });
-
-    if (!is_test) {
-        if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = linkage });
-            @export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = linkage });
-
-            @export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = linkage });
-            @export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = linkage });
-
-            @export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = linkage });
-
-            @export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = linkage });
-
-            @export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = linkage });
-            @export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = linkage });
-        }
-
-        if (arch.isPPC() or arch.isPPC64()) {
-            @export(__fixkfdi, .{ .name = "__fixkfdi", .linkage = linkage });
-            @export(__fixkfsi, .{ .name = "__fixkfsi", .linkage = linkage });
-            @export(__fixunskfsi, .{ .name = "__fixunskfsi", .linkage = linkage });
-            @export(__fixunskfdi, .{ .name = "__fixunskfdi", .linkage = linkage });
-        }
-    }
-}
-
-pub inline fn fixXfYi(comptime I: type, a: anytype) I {
-    @setRuntimeSafety(is_test);
-
-    const F = @TypeOf(a);
-    const float_bits = @typeInfo(F).Float.bits;
-    const int_bits = @typeInfo(I).Int.bits;
-    const rep_t = std.meta.Int(.unsigned, float_bits);
-    const sig_bits = math.floatMantissaBits(F);
-    const exp_bits = math.floatExponentBits(F);
-    const fractional_bits = math.floatFractionalBits(F);
-
-    const implicit_bit = if (F != f80) (@as(rep_t, 1) << sig_bits) else 0;
-    const max_exp = (1 << (exp_bits - 1));
-    const exp_bias = max_exp - 1;
-    const sig_mask = (@as(rep_t, 1) << sig_bits) - 1;
-
-    // Break a into sign, exponent, significand
-    const a_rep: rep_t = @bitCast(rep_t, a);
-    const negative = (a_rep >> (float_bits - 1)) != 0;
-    const exponent = @intCast(i32, (a_rep << 1) >> (sig_bits + 1)) - exp_bias;
-    const significand: rep_t = (a_rep & sig_mask) | implicit_bit;
-
-    // If the exponent is negative, the result rounds to zero.
-    if (exponent < 0) return 0;
-
-    // If the value is too large for the integer type, saturate.
-    switch (@typeInfo(I).Int.signedness) {
-        .unsigned => {
-            if (negative) return 0;
-            if (@intCast(c_uint, exponent) >= @minimum(int_bits, max_exp)) return math.maxInt(I);
-        },
-        .signed => if (@intCast(c_uint, exponent) >= @minimum(int_bits - 1, max_exp)) {
-            return if (negative) math.minInt(I) else math.maxInt(I);
-        },
-    }
-
-    // If 0 <= exponent < sig_bits, right shift to get the result.
-    // Otherwise, shift left.
-    var result: I = undefined;
-    if (exponent < fractional_bits) {
-        result = @intCast(I, significand >> @intCast(Log2Int(rep_t), fractional_bits - exponent));
-    } else {
-        result = @intCast(I, significand) << @intCast(Log2Int(I), exponent - fractional_bits);
-    }
-
-    if ((@typeInfo(I).Int.signedness == .signed) and negative)
-        return ~result +% 1;
-    return result;
-}
-
-// Conversion from f16
-
-pub fn __fixhfsi(a: f16) callconv(.C) i32 {
-    return fixXfYi(i32, a);
-}
-
-pub fn __fixunshfsi(a: f16) callconv(.C) u32 {
-    return fixXfYi(u32, a);
-}
-
-pub fn __fixhfdi(a: f16) callconv(.C) i64 {
-    return fixXfYi(i64, a);
-}
-
-pub fn __fixunshfdi(a: f16) callconv(.C) u64 {
-    return fixXfYi(u64, a);
-}
-
-pub fn __fixhfti(a: f16) callconv(.C) i128 {
-    return fixXfYi(i128, a);
-}
-
-pub fn __fixunshfti(a: f16) callconv(.C) u128 {
-    return fixXfYi(u128, a);
-}
-
-// Conversion from f32
-
-pub fn __fixsfsi(a: f32) callconv(.C) i32 {
-    return fixXfYi(i32, a);
-}
-
-pub fn __fixunssfsi(a: f32) callconv(.C) u32 {
-    return fixXfYi(u32, a);
-}
-
-pub fn __fixsfdi(a: f32) callconv(.C) i64 {
-    return fixXfYi(i64, a);
-}
-
-pub fn __fixunssfdi(a: f32) callconv(.C) u64 {
-    return fixXfYi(u64, a);
-}
-
-pub fn __fixsfti(a: f32) callconv(.C) i128 {
-    return fixXfYi(i128, a);
-}
-
-pub fn __fixunssfti(a: f32) callconv(.C) u128 {
-    return fixXfYi(u128, a);
-}
-
-// Conversion from f64
-
-pub fn __fixdfsi(a: f64) callconv(.C) i32 {
-    return fixXfYi(i32, a);
-}
-
-pub fn __fixunsdfsi(a: f64) callconv(.C) u32 {
-    return fixXfYi(u32, a);
-}
-
-pub fn __fixdfdi(a: f64) callconv(.C) i64 {
-    return fixXfYi(i64, a);
-}
-
-pub fn __fixunsdfdi(a: f64) callconv(.C) u64 {
-    return fixXfYi(u64, a);
-}
-
-pub fn __fixdfti(a: f64) callconv(.C) i128 {
-    return fixXfYi(i128, a);
-}
-
-pub fn __fixunsdfti(a: f64) callconv(.C) u128 {
-    return fixXfYi(u128, a);
-}
-
-// Conversion from f80
-
-pub fn __fixxfsi(a: f80) callconv(.C) i32 {
-    return fixXfYi(i32, a);
-}
-
-pub fn __fixunsxfsi(a: f80) callconv(.C) u32 {
-    return fixXfYi(u32, a);
-}
-
-pub fn __fixxfdi(a: f80) callconv(.C) i64 {
-    return fixXfYi(i64, a);
-}
-
-pub fn __fixunsxfdi(a: f80) callconv(.C) u64 {
-    return fixXfYi(u64, a);
-}
-
-pub fn __fixxfti(a: f80) callconv(.C) i128 {
-    return fixXfYi(i128, a);
-}
-
-pub fn __fixunsxfti(a: f80) callconv(.C) u128 {
-    return fixXfYi(u128, a);
-}
-
-// Conversion from f128
-
-pub fn __fixtfsi(a: f128) callconv(.C) i32 {
-    return fixXfYi(i32, a);
-}
-
-pub fn __fixkfsi(a: f128) callconv(.C) i32 {
-    return __fixtfsi(a);
-}
-
-pub fn __fixunstfsi(a: f128) callconv(.C) u32 {
-    return fixXfYi(u32, a);
-}
-
-pub fn __fixunskfsi(a: f128) callconv(.C) u32 {
-    return @call(.{ .modifier = .always_inline }, __fixunstfsi, .{a});
-}
-
-pub fn __fixtfdi(a: f128) callconv(.C) i64 {
-    return fixXfYi(i64, a);
-}
-
-pub fn __fixkfdi(a: f128) callconv(.C) i64 {
-    return @call(.{ .modifier = .always_inline }, __fixtfdi, .{a});
-}
-
-pub fn __fixunstfdi(a: f128) callconv(.C) u64 {
-    return fixXfYi(u64, a);
-}
-
-pub fn __fixunskfdi(a: f128) callconv(.C) u64 {
-    return @call(.{ .modifier = .always_inline }, __fixunstfdi, .{a});
-}
-
-pub fn __fixtfti(a: f128) callconv(.C) i128 {
-    return fixXfYi(i128, a);
-}
-
-pub fn __fixunstfti(a: f128) callconv(.C) u128 {
-    return fixXfYi(u128, a);
-}
-
-// Conversion from f32
-
-pub fn __aeabi_f2iz(a: f32) callconv(.AAPCS) i32 {
-    return fixXfYi(i32, a);
-}
-
-pub fn __aeabi_f2uiz(a: f32) callconv(.AAPCS) u32 {
-    return fixXfYi(u32, a);
-}
-
-pub fn __aeabi_f2lz(a: f32) callconv(.AAPCS) i64 {
-    return fixXfYi(i64, a);
-}
-
-pub fn __aeabi_f2ulz(a: f32) callconv(.AAPCS) u64 {
-    return fixXfYi(u64, a);
-}
-
-// Conversion from f64
-
-pub fn __aeabi_d2iz(a: f64) callconv(.AAPCS) i32 {
-    return fixXfYi(i32, a);
-}
-
-pub fn __aeabi_d2uiz(a: f64) callconv(.AAPCS) u32 {
-    return fixXfYi(u32, a);
-}
-
-pub fn __aeabi_d2lz(a: f64) callconv(.AAPCS) i64 {
-    return fixXfYi(i64, a);
-}
-
-pub fn __aeabi_d2ulz(a: f64) callconv(.AAPCS) u64 {
-    return fixXfYi(u64, a);
-}
-
-test {
-    _ = @import("fixXfYi_test.zig");
-}
diff --git a/lib/compiler_rt/fixXfYi_test.zig b/lib/compiler_rt/fixXfYi_test.zig
deleted file mode 100644
index 00ed455609a4d5fbb5624ef9ceaddc13856e210c..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/fixXfYi_test.zig
+++ /dev/null
@@ -1,948 +0,0 @@
-const std = @import("std");
-const testing = std.testing;
-const math = std.math;
-const fixXfYi = @import("fixXfYi.zig").fixXfYi;
-
-// Conversion from f32
-const __fixsfsi = @import("fixXfYi.zig").__fixsfsi;
-const __fixunssfsi = @import("fixXfYi.zig").__fixunssfsi;
-const __fixsfdi = @import("fixXfYi.zig").__fixsfdi;
-const __fixunssfdi = @import("fixXfYi.zig").__fixunssfdi;
-const __fixsfti = @import("fixXfYi.zig").__fixsfti;
-const __fixunssfti = @import("fixXfYi.zig").__fixunssfti;
-
-// Conversion from f64
-const __fixdfsi = @import("fixXfYi.zig").__fixdfsi;
-const __fixunsdfsi = @import("fixXfYi.zig").__fixunsdfsi;
-const __fixdfdi = @import("fixXfYi.zig").__fixdfdi;
-const __fixunsdfdi = @import("fixXfYi.zig").__fixunsdfdi;
-const __fixdfti = @import("fixXfYi.zig").__fixdfti;
-const __fixunsdfti = @import("fixXfYi.zig").__fixunsdfti;
-
-// Conversion from f128
-const __fixtfsi = @import("fixXfYi.zig").__fixtfsi;
-const __fixunstfsi = @import("fixXfYi.zig").__fixunstfsi;
-const __fixtfdi = @import("fixXfYi.zig").__fixtfdi;
-const __fixunstfdi = @import("fixXfYi.zig").__fixunstfdi;
-const __fixtfti = @import("fixXfYi.zig").__fixtfti;
-const __fixunstfti = @import("fixXfYi.zig").__fixunstfti;
-
-fn test__fixsfsi(a: f32, expected: i32) !void {
-    const x = __fixsfsi(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunssfsi(a: f32, expected: u32) !void {
-    const x = __fixunssfsi(a);
-    try testing.expect(x == expected);
-}
-
-test "fixsfsi" {
-    try test__fixsfsi(-math.floatMax(f32), math.minInt(i32));
-
-    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
-    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
-
-    try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);
-    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
-    try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
-
-    try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
-    try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
-    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
-    try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
-
-    try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
-    try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);
-
-    try test__fixsfsi(-0x1.000000p+31, -0x80000000);
-    try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);
-    try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
-    try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
-
-    try test__fixsfsi(-2.01, -2);
-    try test__fixsfsi(-2.0, -2);
-    try test__fixsfsi(-1.99, -1);
-    try test__fixsfsi(-1.0, -1);
-    try test__fixsfsi(-0.99, 0);
-    try test__fixsfsi(-0.5, 0);
-    try test__fixsfsi(-math.floatMin(f32), 0);
-    try test__fixsfsi(0.0, 0);
-    try test__fixsfsi(math.floatMin(f32), 0);
-    try test__fixsfsi(0.5, 0);
-    try test__fixsfsi(0.99, 0);
-    try test__fixsfsi(1.0, 1);
-    try test__fixsfsi(1.5, 1);
-    try test__fixsfsi(1.99, 1);
-    try test__fixsfsi(2.0, 2);
-    try test__fixsfsi(2.01, 2);
-
-    try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
-    try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
-    try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);
-
-    try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
-
-    try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
-
-    try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
-
-    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
-    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
-
-    try test__fixsfsi(math.floatMax(f32), math.maxInt(i32));
-}
-
-test "fixunssfsi" {
-    try test__fixunssfsi(0.0, 0);
-
-    try test__fixunssfsi(0.5, 0);
-    try test__fixunssfsi(0.99, 0);
-    try test__fixunssfsi(1.0, 1);
-    try test__fixunssfsi(1.5, 1);
-    try test__fixunssfsi(1.99, 1);
-    try test__fixunssfsi(2.0, 2);
-    try test__fixunssfsi(2.01, 2);
-    try test__fixunssfsi(-0.5, 0);
-    try test__fixunssfsi(-0.99, 0);
-
-    try test__fixunssfsi(-1.0, 0);
-    try test__fixunssfsi(-1.5, 0);
-    try test__fixunssfsi(-1.99, 0);
-    try test__fixunssfsi(-2.0, 0);
-    try test__fixunssfsi(-2.01, 0);
-
-    try test__fixunssfsi(0x1.000000p+31, 0x80000000);
-    try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
-    try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
-    try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
-    try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
-
-    try test__fixunssfsi(-0x1.FFFFFEp+30, 0);
-    try test__fixunssfsi(-0x1.FFFFFCp+30, 0);
-}
-
-fn test__fixsfdi(a: f32, expected: i64) !void {
-    const x = __fixsfdi(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunssfdi(a: f32, expected: u64) !void {
-    const x = __fixunssfdi(a);
-    try testing.expect(x == expected);
-}
-
-test "fixsfdi" {
-    try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
-
-    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
-    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
-
-    try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
-    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
-    try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
-
-    try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
-    try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
-    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
-    try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
-
-    try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
-    try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
-    try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
-
-    try test__fixsfdi(-2.01, -2);
-    try test__fixsfdi(-2.0, -2);
-    try test__fixsfdi(-1.99, -1);
-    try test__fixsfdi(-1.0, -1);
-    try test__fixsfdi(-0.99, 0);
-    try test__fixsfdi(-0.5, 0);
-    try test__fixsfdi(-math.floatMin(f32), 0);
-    try test__fixsfdi(0.0, 0);
-    try test__fixsfdi(math.floatMin(f32), 0);
-    try test__fixsfdi(0.5, 0);
-    try test__fixsfdi(0.99, 0);
-    try test__fixsfdi(1.0, 1);
-    try test__fixsfdi(1.5, 1);
-    try test__fixsfdi(1.99, 1);
-    try test__fixsfdi(2.0, 2);
-    try test__fixsfdi(2.01, 2);
-
-    try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-    try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-    try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
-
-    try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
-    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
-    try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
-    try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
-
-    try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
-    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
-    try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
-
-    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
-    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
-
-    try test__fixsfdi(math.floatMax(f32), math.maxInt(i64));
-}
-
-test "fixunssfdi" {
-    try test__fixunssfdi(0.0, 0);
-
-    try test__fixunssfdi(0.5, 0);
-    try test__fixunssfdi(0.99, 0);
-    try test__fixunssfdi(1.0, 1);
-    try test__fixunssfdi(1.5, 1);
-    try test__fixunssfdi(1.99, 1);
-    try test__fixunssfdi(2.0, 2);
-    try test__fixunssfdi(2.01, 2);
-    try test__fixunssfdi(-0.5, 0);
-    try test__fixunssfdi(-0.99, 0);
-
-    try test__fixunssfdi(-1.0, 0);
-    try test__fixunssfdi(-1.5, 0);
-    try test__fixunssfdi(-1.99, 0);
-    try test__fixunssfdi(-2.0, 0);
-    try test__fixunssfdi(-2.01, 0);
-
-    try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
-    try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
-    try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-    try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-
-    try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
-    try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
-}
-
-fn test__fixsfti(a: f32, expected: i128) !void {
-    const x = __fixsfti(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunssfti(a: f32, expected: u128) !void {
-    const x = __fixunssfti(a);
-    try testing.expect(x == expected);
-}
-
-test "fixsfti" {
-    try test__fixsfti(-math.floatMax(f32), math.minInt(i128));
-
-    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
-    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
-
-    try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
-    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
-    try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
-    try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
-    try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
-    try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
-
-    try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);
-    try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);
-    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
-    try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
-
-    try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
-    try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
-    try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
-
-    try test__fixsfti(-0x1.000000p+31, -0x80000000);
-    try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);
-    try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);
-    try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);
-
-    try test__fixsfti(-2.01, -2);
-    try test__fixsfti(-2.0, -2);
-    try test__fixsfti(-1.99, -1);
-    try test__fixsfti(-1.0, -1);
-    try test__fixsfti(-0.99, 0);
-    try test__fixsfti(-0.5, 0);
-    try test__fixsfti(-math.floatMin(f32), 0);
-    try test__fixsfti(0.0, 0);
-    try test__fixsfti(math.floatMin(f32), 0);
-    try test__fixsfti(0.5, 0);
-    try test__fixsfti(0.99, 0);
-    try test__fixsfti(1.0, 1);
-    try test__fixsfti(1.5, 1);
-    try test__fixsfti(1.99, 1);
-    try test__fixsfti(2.0, 2);
-    try test__fixsfti(2.01, 2);
-
-    try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);
-    try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);
-    try test__fixsfti(0x1.FFFFFFp+30, 0x80000000);
-    try test__fixsfti(0x1.000000p+31, 0x80000000);
-
-    try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-    try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-    try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);
-
-    try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
-    try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
-    try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);
-    try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);
-
-    try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
-    try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
-    try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-    try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-    try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-    try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-
-    try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-    try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
-
-    try test__fixsfti(math.floatMax(f32), math.maxInt(i128));
-}
-
-test "fixunssfti" {
-    try test__fixunssfti(0.0, 0);
-
-    try test__fixunssfti(0.5, 0);
-    try test__fixunssfti(0.99, 0);
-    try test__fixunssfti(1.0, 1);
-    try test__fixunssfti(1.5, 1);
-    try test__fixunssfti(1.99, 1);
-    try test__fixunssfti(2.0, 2);
-    try test__fixunssfti(2.01, 2);
-    try test__fixunssfti(-0.5, 0);
-    try test__fixunssfti(-0.99, 0);
-
-    try test__fixunssfti(-1.0, 0);
-    try test__fixunssfti(-1.5, 0);
-    try test__fixunssfti(-1.99, 0);
-    try test__fixunssfti(-2.0, 0);
-    try test__fixunssfti(-2.01, 0);
-
-    try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
-    try test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
-    try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-    try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-    try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
-    try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
-    try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
-    try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
-
-    try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
-    try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
-    try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
-    try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
-    try test__fixunssfti(math.floatMax(f32), 0xffffff00000000000000000000000000);
-    try test__fixunssfti(math.inf(f32), math.maxInt(u128));
-}
-
-fn test__fixdfsi(a: f64, expected: i32) !void {
-    const x = __fixdfsi(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunsdfsi(a: f64, expected: u32) !void {
-    const x = __fixunsdfsi(a);
-    try testing.expect(x == expected);
-}
-
-test "fixdfsi" {
-    try test__fixdfsi(-math.floatMax(f64), math.minInt(i32));
-
-    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
-    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
-
-    try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);
-    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
-    try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
-
-    try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
-    try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
-    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
-    try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
-
-    try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
-    try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);
-
-    try test__fixdfsi(-0x1.000000p+31, -0x80000000);
-    try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
-    try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
-
-    try test__fixdfsi(-2.01, -2);
-    try test__fixdfsi(-2.0, -2);
-    try test__fixdfsi(-1.99, -1);
-    try test__fixdfsi(-1.0, -1);
-    try test__fixdfsi(-0.99, 0);
-    try test__fixdfsi(-0.5, 0);
-    try test__fixdfsi(-math.floatMin(f64), 0);
-    try test__fixdfsi(0.0, 0);
-    try test__fixdfsi(math.floatMin(f64), 0);
-    try test__fixdfsi(0.5, 0);
-    try test__fixdfsi(0.99, 0);
-    try test__fixdfsi(1.0, 1);
-    try test__fixdfsi(1.5, 1);
-    try test__fixdfsi(1.99, 1);
-    try test__fixdfsi(2.0, 2);
-    try test__fixdfsi(2.01, 2);
-
-    try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
-    try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
-    try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);
-
-    try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
-    try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
-
-    try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
-    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
-    try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
-    try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
-
-    try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
-    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
-    try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
-
-    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
-    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
-
-    try test__fixdfsi(math.floatMax(f64), math.maxInt(i32));
-}
-
-test "fixunsdfsi" {
-    try test__fixunsdfsi(0.0, 0);
-
-    try test__fixunsdfsi(0.5, 0);
-    try test__fixunsdfsi(0.99, 0);
-    try test__fixunsdfsi(1.0, 1);
-    try test__fixunsdfsi(1.5, 1);
-    try test__fixunsdfsi(1.99, 1);
-    try test__fixunsdfsi(2.0, 2);
-    try test__fixunsdfsi(2.01, 2);
-    try test__fixunsdfsi(-0.5, 0);
-    try test__fixunsdfsi(-0.99, 0);
-    try test__fixunsdfsi(-1.0, 0);
-    try test__fixunsdfsi(-1.5, 0);
-    try test__fixunsdfsi(-1.99, 0);
-    try test__fixunsdfsi(-2.0, 0);
-    try test__fixunsdfsi(-2.01, 0);
-
-    try test__fixunsdfsi(0x1.000000p+31, 0x80000000);
-    try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
-    try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
-    try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
-    try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
-
-    try test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
-    try test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
-
-    try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
-    try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
-    try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
-}
-
-fn test__fixdfdi(a: f64, expected: i64) !void {
-    const x = __fixdfdi(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunsdfdi(a: f64, expected: u64) !void {
-    const x = __fixunsdfdi(a);
-    try testing.expect(x == expected);
-}
-
-test "fixdfdi" {
-    try test__fixdfdi(-math.floatMax(f64), math.minInt(i64));
-
-    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
-    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
-
-    try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);
-    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
-    try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
-
-    try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);
-    try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);
-    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
-    try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
-
-    try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
-    try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
-
-    try test__fixdfdi(-2.01, -2);
-    try test__fixdfdi(-2.0, -2);
-    try test__fixdfdi(-1.99, -1);
-    try test__fixdfdi(-1.0, -1);
-    try test__fixdfdi(-0.99, 0);
-    try test__fixdfdi(-0.5, 0);
-    try test__fixdfdi(-math.floatMin(f64), 0);
-    try test__fixdfdi(0.0, 0);
-    try test__fixdfdi(math.floatMin(f64), 0);
-    try test__fixdfdi(0.5, 0);
-    try test__fixdfdi(0.99, 0);
-    try test__fixdfdi(1.0, 1);
-    try test__fixdfdi(1.5, 1);
-    try test__fixdfdi(1.99, 1);
-    try test__fixdfdi(2.0, 2);
-    try test__fixdfdi(2.01, 2);
-
-    try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-    try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-
-    try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
-    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
-    try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
-    try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
-
-    try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
-    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
-    try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
-
-    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
-    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
-
-    try test__fixdfdi(math.floatMax(f64), math.maxInt(i64));
-}
-
-test "fixunsdfdi" {
-    try test__fixunsdfdi(0.0, 0);
-    try test__fixunsdfdi(0.5, 0);
-    try test__fixunsdfdi(0.99, 0);
-    try test__fixunsdfdi(1.0, 1);
-    try test__fixunsdfdi(1.5, 1);
-    try test__fixunsdfdi(1.99, 1);
-    try test__fixunsdfdi(2.0, 2);
-    try test__fixunsdfdi(2.01, 2);
-    try test__fixunsdfdi(-0.5, 0);
-    try test__fixunsdfdi(-0.99, 0);
-    try test__fixunsdfdi(-1.0, 0);
-    try test__fixunsdfdi(-1.5, 0);
-    try test__fixunsdfdi(-1.99, 0);
-    try test__fixunsdfdi(-2.0, 0);
-    try test__fixunsdfdi(-2.01, 0);
-
-    try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-    try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-
-    try test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
-    try test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
-
-    try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
-    try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
-    try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
-    try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
-
-    try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
-    try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
-}
-
-fn test__fixdfti(a: f64, expected: i128) !void {
-    const x = __fixdfti(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunsdfti(a: f64, expected: u128) !void {
-    const x = __fixunsdfti(a);
-    try testing.expect(x == expected);
-}
-
-test "fixdfti" {
-    try test__fixdfti(-math.floatMax(f64), math.minInt(i128));
-
-    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
-    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
-
-    try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
-    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
-    try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
-
-    try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);
-    try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);
-    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
-    try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
-
-    try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
-    try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
-
-    try test__fixdfti(-2.01, -2);
-    try test__fixdfti(-2.0, -2);
-    try test__fixdfti(-1.99, -1);
-    try test__fixdfti(-1.0, -1);
-    try test__fixdfti(-0.99, 0);
-    try test__fixdfti(-0.5, 0);
-    try test__fixdfti(-math.floatMin(f64), 0);
-    try test__fixdfti(0.0, 0);
-    try test__fixdfti(math.floatMin(f64), 0);
-    try test__fixdfti(0.5, 0);
-    try test__fixdfti(0.99, 0);
-    try test__fixdfti(1.0, 1);
-    try test__fixdfti(1.5, 1);
-    try test__fixdfti(1.99, 1);
-    try test__fixdfti(2.0, 2);
-    try test__fixdfti(2.01, 2);
-
-    try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-    try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-
-    try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
-    try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
-    try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);
-    try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);
-
-    try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
-    try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
-    try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-
-    try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-    try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
-
-    try test__fixdfti(math.floatMax(f64), math.maxInt(i128));
-}
-
-test "fixunsdfti" {
-    try test__fixunsdfti(0.0, 0);
-
-    try test__fixunsdfti(0.5, 0);
-    try test__fixunsdfti(0.99, 0);
-    try test__fixunsdfti(1.0, 1);
-    try test__fixunsdfti(1.5, 1);
-    try test__fixunsdfti(1.99, 1);
-    try test__fixunsdfti(2.0, 2);
-    try test__fixunsdfti(2.01, 2);
-    try test__fixunsdfti(-0.5, 0);
-    try test__fixunsdfti(-0.99, 0);
-    try test__fixunsdfti(-1.0, 0);
-    try test__fixunsdfti(-1.5, 0);
-    try test__fixunsdfti(-1.99, 0);
-    try test__fixunsdfti(-2.0, 0);
-    try test__fixunsdfti(-2.01, 0);
-
-    try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-    try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-
-    try test__fixunsdfti(-0x1.FFFFFEp+62, 0);
-    try test__fixunsdfti(-0x1.FFFFFCp+62, 0);
-
-    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
-    try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
-    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
-    try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
-
-    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
-    try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
-    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
-    try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
-    try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-
-    try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
-    try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
-}
-
-fn test__fixtfsi(a: f128, expected: i32) !void {
-    const x = __fixtfsi(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunstfsi(a: f128, expected: u32) !void {
-    const x = __fixunstfsi(a);
-    try testing.expect(x == expected);
-}
-
-test "fixtfsi" {
-    try test__fixtfsi(-math.floatMax(f128), math.minInt(i32));
-
-    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
-    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
-
-    try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);
-    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
-    try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
-
-    try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
-    try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
-    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
-    try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
-
-    try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
-    try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);
-
-    try test__fixtfsi(-0x1.000000p+31, -0x80000000);
-    try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
-    try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
-    try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
-
-    try test__fixtfsi(-2.01, -2);
-    try test__fixtfsi(-2.0, -2);
-    try test__fixtfsi(-1.99, -1);
-    try test__fixtfsi(-1.0, -1);
-    try test__fixtfsi(-0.99, 0);
-    try test__fixtfsi(-0.5, 0);
-    try test__fixtfsi(-math.floatMin(f32), 0);
-    try test__fixtfsi(0.0, 0);
-    try test__fixtfsi(math.floatMin(f32), 0);
-    try test__fixtfsi(0.5, 0);
-    try test__fixtfsi(0.99, 0);
-    try test__fixtfsi(1.0, 1);
-    try test__fixtfsi(1.5, 1);
-    try test__fixtfsi(1.99, 1);
-    try test__fixtfsi(2.0, 2);
-    try test__fixtfsi(2.01, 2);
-
-    try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
-    try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
-    try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
-    try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);
-
-    try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
-    try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
-
-    try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
-    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
-    try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
-    try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
-
-    try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
-    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
-    try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
-
-    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
-    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
-
-    try test__fixtfsi(math.floatMax(f128), math.maxInt(i32));
-}
-
-test "fixunstfsi" {
-    try test__fixunstfsi(math.inf(f128), 0xffffffff);
-    try test__fixunstfsi(0, 0x0);
-    try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
-    try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);
-    try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);
-    try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);
-    try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);
-    try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);
-
-    try test__fixunstfsi(0x1p+32, 0xFFFFFFFF);
-}
-
-fn test__fixtfdi(a: f128, expected: i64) !void {
-    const x = __fixtfdi(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunstfdi(a: f128, expected: u64) !void {
-    const x = __fixunstfdi(a);
-    try testing.expect(x == expected);
-}
-
-test "fixtfdi" {
-    try test__fixtfdi(-math.floatMax(f128), math.minInt(i64));
-
-    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
-    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
-
-    try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);
-    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
-    try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
-
-    try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
-    try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
-    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
-    try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
-
-    try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
-    try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
-
-    try test__fixtfdi(-0x1.000000p+31, -0x80000000);
-    try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
-    try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);
-    try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);
-
-    try test__fixtfdi(-2.01, -2);
-    try test__fixtfdi(-2.0, -2);
-    try test__fixtfdi(-1.99, -1);
-    try test__fixtfdi(-1.0, -1);
-    try test__fixtfdi(-0.99, 0);
-    try test__fixtfdi(-0.5, 0);
-    try test__fixtfdi(-math.floatMin(f64), 0);
-    try test__fixtfdi(0.0, 0);
-    try test__fixtfdi(math.floatMin(f64), 0);
-    try test__fixtfdi(0.5, 0);
-    try test__fixtfdi(0.99, 0);
-    try test__fixtfdi(1.0, 1);
-    try test__fixtfdi(1.5, 1);
-    try test__fixtfdi(1.99, 1);
-    try test__fixtfdi(2.0, 2);
-    try test__fixtfdi(2.01, 2);
-
-    try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);
-    try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);
-    try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);
-    try test__fixtfdi(0x1.000000p+31, 0x80000000);
-
-    try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-    try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-
-    try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
-    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
-    try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
-    try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
-
-    try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
-    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
-    try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
-
-    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
-    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
-
-    try test__fixtfdi(math.floatMax(f128), math.maxInt(i64));
-}
-
-test "fixunstfdi" {
-    try test__fixunstfdi(0.0, 0);
-
-    try test__fixunstfdi(0.5, 0);
-    try test__fixunstfdi(0.99, 0);
-    try test__fixunstfdi(1.0, 1);
-    try test__fixunstfdi(1.5, 1);
-    try test__fixunstfdi(1.99, 1);
-    try test__fixunstfdi(2.0, 2);
-    try test__fixunstfdi(2.01, 2);
-    try test__fixunstfdi(-0.5, 0);
-    try test__fixunstfdi(-0.99, 0);
-    try test__fixunstfdi(-1.0, 0);
-    try test__fixunstfdi(-1.5, 0);
-    try test__fixunstfdi(-1.99, 0);
-    try test__fixunstfdi(-2.0, 0);
-    try test__fixunstfdi(-2.01, 0);
-
-    try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-    try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-
-    try test__fixunstfdi(-0x1.FFFFFEp+62, 0);
-    try test__fixunstfdi(-0x1.FFFFFCp+62, 0);
-
-    try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
-    try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
-
-    try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
-    try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
-
-    try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
-    try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
-    try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
-    try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
-    try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
-    try test__fixunstfdi(0x1p+64, 0xFFFFFFFFFFFFFFFF);
-
-    try test__fixunstfdi(-0x1.0000000000000000p+63, 0);
-    try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
-    try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
-}
-
-fn test__fixtfti(a: f128, expected: i128) !void {
-    const x = __fixtfti(a);
-    try testing.expect(x == expected);
-}
-
-fn test__fixunstfti(a: f128, expected: u128) !void {
-    const x = __fixunstfti(a);
-    try testing.expect(x == expected);
-}
-
-test "fixtfti" {
-    try test__fixtfti(-math.floatMax(f128), math.minInt(i128));
-
-    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
-    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
-
-    try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
-    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
-    try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
-
-    try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);
-    try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);
-    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
-    try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
-
-    try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
-    try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
-
-    try test__fixtfti(-2.01, -2);
-    try test__fixtfti(-2.0, -2);
-    try test__fixtfti(-1.99, -1);
-    try test__fixtfti(-1.0, -1);
-    try test__fixtfti(-0.99, 0);
-    try test__fixtfti(-0.5, 0);
-    try test__fixtfti(-math.floatMin(f128), 0);
-    try test__fixtfti(0.0, 0);
-    try test__fixtfti(math.floatMin(f128), 0);
-    try test__fixtfti(0.5, 0);
-    try test__fixtfti(0.99, 0);
-    try test__fixtfti(1.0, 1);
-    try test__fixtfti(1.5, 1);
-    try test__fixtfti(1.99, 1);
-    try test__fixtfti(2.0, 2);
-    try test__fixtfti(2.01, 2);
-
-    try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
-    try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
-
-    try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
-    try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
-    try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);
-    try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);
-
-    try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
-    try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
-    try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-
-    try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
-    try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
-
-    try test__fixtfti(math.floatMax(f128), math.maxInt(i128));
-}
-
-test "fixunstfti" {
-    try test__fixunstfti(math.inf(f128), 0xffffffffffffffffffffffffffffffff);
-
-    try test__fixunstfti(0.0, 0);
-
-    try test__fixunstfti(0.5, 0);
-    try test__fixunstfti(0.99, 0);
-    try test__fixunstfti(1.0, 1);
-    try test__fixunstfti(1.5, 1);
-    try test__fixunstfti(1.99, 1);
-    try test__fixunstfti(2.0, 2);
-    try test__fixunstfti(2.01, 2);
-    try test__fixunstfti(-0.01, 0);
-    try test__fixunstfti(-0.99, 0);
-
-    try test__fixunstfti(0x1p+128, 0xffffffffffffffffffffffffffffffff);
-
-    try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
-    try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
-    try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
-    try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
-}
-
-fn test__fixunshfti(a: f16, expected: u128) !void {
-    const x = fixXfYi(u128, a);
-    try testing.expect(x == expected);
-}
-
-test "fixXfYi for f16" {
-    try test__fixunshfti(math.inf(f16), math.maxInt(u128));
-    try test__fixunshfti(math.floatMax(f16), 65504);
-}
-
-fn test__fixunsxfti(a: f80, expected: u128) !void {
-    const x = fixXfYi(u128, a);
-    try testing.expect(x == expected);
-}
-
-test "fixXfYi for f80" {
-    try test__fixunsxfti(math.inf(f80), math.maxInt(u128));
-    try test__fixunsxfti(math.floatMax(f80), math.maxInt(u128));
-    try test__fixunsxfti(math.maxInt(u64), math.maxInt(u64));
-}
diff --git a/lib/compiler_rt/fixdfdi.zig b/lib/compiler_rt/fixdfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2c3204db65170be632544a8cbdea4d49b0ed4196
--- /dev/null
+++ b/lib/compiler_rt/fixdfdi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_d2lz, .{ .name = "__aeabi_d2lz", .linkage = common.linkage });
+    } else {
+        @export(__fixdfdi, .{ .name = "__fixdfdi", .linkage = common.linkage });
+    }
+}
+
+fn __fixdfdi(a: f64) callconv(.C) i64 {
+    return floatToInt(i64, a);
+}
+
+fn __aeabi_d2lz(a: f64) callconv(.AAPCS) i64 {
+    return floatToInt(i64, a);
+}
diff --git a/lib/compiler_rt/fixdfsi.zig b/lib/compiler_rt/fixdfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..415160f1de92d3c22cb4d4517af46f1e20ab1951
--- /dev/null
+++ b/lib/compiler_rt/fixdfsi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_d2iz, .{ .name = "__aeabi_d2iz", .linkage = common.linkage });
+    } else {
+        @export(__fixdfsi, .{ .name = "__fixdfsi", .linkage = common.linkage });
+    }
+}
+
+fn __fixdfsi(a: f64) callconv(.C) i32 {
+    return floatToInt(i32, a);
+}
+
+fn __aeabi_d2iz(a: f64) callconv(.AAPCS) i32 {
+    return floatToInt(i32, a);
+}
diff --git a/lib/compiler_rt/fixdfti.zig b/lib/compiler_rt/fixdfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..56ae2bbeb2aa9df19c720984475d3030d2760e4a
--- /dev/null
+++ b/lib/compiler_rt/fixdfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixdfti, .{ .name = "__fixdfti", .linkage = common.linkage });
+}
+
+fn __fixdfti(a: f64) callconv(.C) i128 {
+    return floatToInt(i128, a);
+}
diff --git a/lib/compiler_rt/fixhfdi.zig b/lib/compiler_rt/fixhfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..28e871f495b16bde5f5602049da73101907f100b
--- /dev/null
+++ b/lib/compiler_rt/fixhfdi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixhfdi, .{ .name = "__fixhfdi", .linkage = common.linkage });
+}
+
+fn __fixhfdi(a: f16) callconv(.C) i64 {
+    return floatToInt(i64, a);
+}
diff --git a/lib/compiler_rt/fixhfsi.zig b/lib/compiler_rt/fixhfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..23440eea22e9c5d82d88c1b8f672a0c5bcd5f195
--- /dev/null
+++ b/lib/compiler_rt/fixhfsi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixhfsi, .{ .name = "__fixhfsi", .linkage = common.linkage });
+}
+
+fn __fixhfsi(a: f16) callconv(.C) i32 {
+    return floatToInt(i32, a);
+}
diff --git a/lib/compiler_rt/fixhfti.zig b/lib/compiler_rt/fixhfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..36fc1bf607583b4eeefb05b6731da5b335cdb374
--- /dev/null
+++ b/lib/compiler_rt/fixhfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixhfti, .{ .name = "__fixhfti", .linkage = common.linkage });
+}
+
+fn __fixhfti(a: f16) callconv(.C) i128 {
+    return floatToInt(i128, a);
+}
diff --git a/lib/compiler_rt/fixsfdi.zig b/lib/compiler_rt/fixsfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..71b0f047e2e3520341ea58fccbce5a4e2c56ea3b
--- /dev/null
+++ b/lib/compiler_rt/fixsfdi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_f2lz, .{ .name = "__aeabi_f2lz", .linkage = common.linkage });
+    } else {
+        @export(__fixsfdi, .{ .name = "__fixsfdi", .linkage = common.linkage });
+    }
+}
+
+fn __fixsfdi(a: f32) callconv(.C) i64 {
+    return floatToInt(i64, a);
+}
+
+fn __aeabi_f2lz(a: f32) callconv(.AAPCS) i64 {
+    return floatToInt(i64, a);
+}
diff --git a/lib/compiler_rt/fixsfsi.zig b/lib/compiler_rt/fixsfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d48162928bd136fb80e71743a6552eff2a5979d2
--- /dev/null
+++ b/lib/compiler_rt/fixsfsi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_f2iz, .{ .name = "__aeabi_f2iz", .linkage = common.linkage });
+    } else {
+        @export(__fixsfsi, .{ .name = "__fixsfsi", .linkage = common.linkage });
+    }
+}
+
+fn __fixsfsi(a: f32) callconv(.C) i32 {
+    return floatToInt(i32, a);
+}
+
+fn __aeabi_f2iz(a: f32) callconv(.AAPCS) i32 {
+    return floatToInt(i32, a);
+}
diff --git a/lib/compiler_rt/fixsfti.zig b/lib/compiler_rt/fixsfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aefde49768c4c7ead4370698ce1ce9af492824a2
--- /dev/null
+++ b/lib/compiler_rt/fixsfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixsfti, .{ .name = "__fixsfti", .linkage = common.linkage });
+}
+
+fn __fixsfti(a: f32) callconv(.C) i128 {
+    return floatToInt(i128, a);
+}
diff --git a/lib/compiler_rt/fixtfdi.zig b/lib/compiler_rt/fixtfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..8f8d473b1f491a810255802b2a8960b10e5a2210
--- /dev/null
+++ b/lib/compiler_rt/fixtfdi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__fixkfdi, .{ .name = "__fixkfdi", .linkage = common.linkage });
+    } else {
+        @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage });
+    }
+}
+
+fn __fixtfdi(a: f128) callconv(.C) i64 {
+    return floatToInt(i64, a);
+}
+
+fn __fixkfdi(a: f128) callconv(.C) i64 {
+    return floatToInt(i64, a);
+}
diff --git a/lib/compiler_rt/fixtfsi.zig b/lib/compiler_rt/fixtfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..507581d0cf84637d2c3255a4bf3a8f5a3e016ae7
--- /dev/null
+++ b/lib/compiler_rt/fixtfsi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__fixkfsi, .{ .name = "__fixkfsi", .linkage = common.linkage });
+    } else {
+        @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage });
+    }
+}
+
+fn __fixtfsi(a: f128) callconv(.C) i32 {
+    return floatToInt(i32, a);
+}
+
+fn __fixkfsi(a: f128) callconv(.C) i32 {
+    return floatToInt(i32, a);
+}
diff --git a/lib/compiler_rt/fixtfti.zig b/lib/compiler_rt/fixtfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a50ee5aa7c7274de85de17ed01727b14b4f8e870
--- /dev/null
+++ b/lib/compiler_rt/fixtfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixtfti, .{ .name = "__fixtfti", .linkage = common.linkage });
+}
+
+fn __fixtfti(a: f128) callconv(.C) i128 {
+    return floatToInt(i128, a);
+}
diff --git a/lib/compiler_rt/fixunsdfdi.zig b/lib/compiler_rt/fixunsdfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..afcb969ac68b8dc2d065f82d6ddae4ec7118c5ae
--- /dev/null
+++ b/lib/compiler_rt/fixunsdfdi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_d2ulz, .{ .name = "__aeabi_d2ulz", .linkage = common.linkage });
+    } else {
+        @export(__fixunsdfdi, .{ .name = "__fixunsdfdi", .linkage = common.linkage });
+    }
+}
+
+fn __fixunsdfdi(a: f64) callconv(.C) u64 {
+    return floatToInt(u64, a);
+}
+
+fn __aeabi_d2ulz(a: f64) callconv(.AAPCS) u64 {
+    return floatToInt(u64, a);
+}
diff --git a/lib/compiler_rt/fixunsdfsi.zig b/lib/compiler_rt/fixunsdfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3675eb2c6f34e0a16e6df43e4b19bf741475102f
--- /dev/null
+++ b/lib/compiler_rt/fixunsdfsi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_d2uiz, .{ .name = "__aeabi_d2uiz", .linkage = common.linkage });
+    } else {
+        @export(__fixunsdfsi, .{ .name = "__fixunsdfsi", .linkage = common.linkage });
+    }
+}
+
+fn __fixunsdfsi(a: f64) callconv(.C) u32 {
+    return floatToInt(u32, a);
+}
+
+fn __aeabi_d2uiz(a: f64) callconv(.AAPCS) u32 {
+    return floatToInt(u32, a);
+}
diff --git a/lib/compiler_rt/fixunsdfti.zig b/lib/compiler_rt/fixunsdfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..96dd242f6d6035441dccd3a5e3435f8d8cde3178
--- /dev/null
+++ b/lib/compiler_rt/fixunsdfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunsdfti, .{ .name = "__fixunsdfti", .linkage = common.linkage });
+}
+
+fn __fixunsdfti(a: f64) callconv(.C) u128 {
+    return floatToInt(u128, a);
+}
diff --git a/lib/compiler_rt/fixunshfdi.zig b/lib/compiler_rt/fixunshfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5058bc5e688db8b050cd7d4b074e1ec705241440
--- /dev/null
+++ b/lib/compiler_rt/fixunshfdi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunshfdi, .{ .name = "__fixunshfdi", .linkage = common.linkage });
+}
+
+fn __fixunshfdi(a: f16) callconv(.C) u64 {
+    return floatToInt(u64, a);
+}
diff --git a/lib/compiler_rt/fixunshfsi.zig b/lib/compiler_rt/fixunshfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5755048814e2d5607f0f56c3812c2477f9a52b95
--- /dev/null
+++ b/lib/compiler_rt/fixunshfsi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunshfsi, .{ .name = "__fixunshfsi", .linkage = common.linkage });
+}
+
+fn __fixunshfsi(a: f16) callconv(.C) u32 {
+    return floatToInt(u32, a);
+}
diff --git a/lib/compiler_rt/fixunshfti.zig b/lib/compiler_rt/fixunshfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac013263ebb85004eda1af29c968171ce6e04c84
--- /dev/null
+++ b/lib/compiler_rt/fixunshfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunshfti, .{ .name = "__fixunshfti", .linkage = common.linkage });
+}
+
+fn __fixunshfti(a: f16) callconv(.C) u128 {
+    return floatToInt(u128, a);
+}
diff --git a/lib/compiler_rt/fixunssfdi.zig b/lib/compiler_rt/fixunssfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..223bbcc2b503e9d1e17e67e056ea4b7ebae81780
--- /dev/null
+++ b/lib/compiler_rt/fixunssfdi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_f2ulz, .{ .name = "__aeabi_f2ulz", .linkage = common.linkage });
+    } else {
+        @export(__fixunssfdi, .{ .name = "__fixunssfdi", .linkage = common.linkage });
+    }
+}
+
+fn __fixunssfdi(a: f32) callconv(.C) u64 {
+    return floatToInt(u64, a);
+}
+
+fn __aeabi_f2ulz(a: f32) callconv(.AAPCS) u64 {
+    return floatToInt(u64, a);
+}
diff --git a/lib/compiler_rt/fixunssfsi.zig b/lib/compiler_rt/fixunssfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0a113af5299a35df62e6539fe44c91b1d5d269cf
--- /dev/null
+++ b/lib/compiler_rt/fixunssfsi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_f2uiz, .{ .name = "__aeabi_f2uiz", .linkage = common.linkage });
+    } else {
+        @export(__fixunssfsi, .{ .name = "__fixunssfsi", .linkage = common.linkage });
+    }
+}
+
+fn __fixunssfsi(a: f32) callconv(.C) u32 {
+    return floatToInt(u32, a);
+}
+
+fn __aeabi_f2uiz(a: f32) callconv(.AAPCS) u32 {
+    return floatToInt(u32, a);
+}
diff --git a/lib/compiler_rt/fixunssfti.zig b/lib/compiler_rt/fixunssfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6b7690784dc78c0ae4e922ee6d1090b9c8be27dc
--- /dev/null
+++ b/lib/compiler_rt/fixunssfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunssfti, .{ .name = "__fixunssfti", .linkage = common.linkage });
+}
+
+fn __fixunssfti(a: f32) callconv(.C) u128 {
+    return floatToInt(u128, a);
+}
diff --git a/lib/compiler_rt/fixunstfdi.zig b/lib/compiler_rt/fixunstfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0130f211397dc2c5b5cd36a5acf843ec90e45e7c
--- /dev/null
+++ b/lib/compiler_rt/fixunstfdi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__fixunskfdi, .{ .name = "__fixunskfdi", .linkage = common.linkage });
+    } else {
+        @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = common.linkage });
+    }
+}
+
+fn __fixunstfdi(a: f128) callconv(.C) u64 {
+    return floatToInt(u64, a);
+}
+
+fn __fixunskfdi(a: f128) callconv(.C) u64 {
+    return floatToInt(u64, a);
+}
diff --git a/lib/compiler_rt/fixunstfsi.zig b/lib/compiler_rt/fixunstfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..78e2cc83d438ecef5f38cb6f6b4c95270f1bd09f
--- /dev/null
+++ b/lib/compiler_rt/fixunstfsi.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__fixunskfsi, .{ .name = "__fixunskfsi", .linkage = common.linkage });
+    } else {
+        @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = common.linkage });
+    }
+}
+
+fn __fixunstfsi(a: f128) callconv(.C) u32 {
+    return floatToInt(u32, a);
+}
+
+fn __fixunskfsi(a: f128) callconv(.C) u32 {
+    return floatToInt(u32, a);
+}
diff --git a/lib/compiler_rt/fixunstfti.zig b/lib/compiler_rt/fixunstfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ba3a3ed12ebf7abb48338ec66ecac29cdaa7f099
--- /dev/null
+++ b/lib/compiler_rt/fixunstfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunstfti, .{ .name = "__fixunstfti", .linkage = common.linkage });
+}
+
+fn __fixunstfti(a: f128) callconv(.C) u128 {
+    return floatToInt(u128, a);
+}
diff --git a/lib/compiler_rt/fixunsxfdi.zig b/lib/compiler_rt/fixunsxfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..cb2760af4e77597d983db4c4d5fc0a856d4df721
--- /dev/null
+++ b/lib/compiler_rt/fixunsxfdi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunsxfdi, .{ .name = "__fixunsxfdi", .linkage = common.linkage });
+}
+
+fn __fixunsxfdi(a: f80) callconv(.C) u64 {
+    return floatToInt(u64, a);
+}
diff --git a/lib/compiler_rt/fixunsxfsi.zig b/lib/compiler_rt/fixunsxfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bec36abbf4f87f2dd87acdb45cbdd6dbcaa6a12a
--- /dev/null
+++ b/lib/compiler_rt/fixunsxfsi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunsxfsi, .{ .name = "__fixunsxfsi", .linkage = common.linkage });
+}
+
+fn __fixunsxfsi(a: f80) callconv(.C) u32 {
+    return floatToInt(u32, a);
+}
diff --git a/lib/compiler_rt/fixunsxfti.zig b/lib/compiler_rt/fixunsxfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f2cd85cf2f62e1cbdd2b0720284de9ce78db629f
--- /dev/null
+++ b/lib/compiler_rt/fixunsxfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixunsxfti, .{ .name = "__fixunsxfti", .linkage = common.linkage });
+}
+
+fn __fixunsxfti(a: f80) callconv(.C) u128 {
+    return floatToInt(u128, a);
+}
diff --git a/lib/compiler_rt/fixxfdi.zig b/lib/compiler_rt/fixxfdi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0f249e0a9218e7af75eabe3589deb0830b4495d6
--- /dev/null
+++ b/lib/compiler_rt/fixxfdi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixxfdi, .{ .name = "__fixxfdi", .linkage = common.linkage });
+}
+
+fn __fixxfdi(a: f80) callconv(.C) i64 {
+    return floatToInt(i64, a);
+}
diff --git a/lib/compiler_rt/fixxfsi.zig b/lib/compiler_rt/fixxfsi.zig
new file mode 100644
index 0000000000000000000000000000000000000000..ac2158b7b8cc596e8163595f6dc52aea5d9f584c
--- /dev/null
+++ b/lib/compiler_rt/fixxfsi.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixxfsi, .{ .name = "__fixxfsi", .linkage = common.linkage });
+}
+
+fn __fixxfsi(a: f80) callconv(.C) i32 {
+    return floatToInt(i32, a);
+}
diff --git a/lib/compiler_rt/fixxfti.zig b/lib/compiler_rt/fixxfti.zig
new file mode 100644
index 0000000000000000000000000000000000000000..fb547f4115667b7ceb8ce0d4bdda0955b7d68503
--- /dev/null
+++ b/lib/compiler_rt/fixxfti.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const floatToInt = @import("./float_to_int.zig").floatToInt;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__fixxfti, .{ .name = "__fixxfti", .linkage = common.linkage });
+}
+
+fn __fixxfti(a: f80) callconv(.C) i128 {
+    return floatToInt(i128, a);
+}
diff --git a/lib/compiler_rt/floatXiYf.zig b/lib/compiler_rt/floatXiYf.zig
deleted file mode 100644
index 25f57434919511166352e5085cf1d43c1bc4892e..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/floatXiYf.zig
+++ /dev/null
@@ -1,311 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-const math = std.math;
-const expect = std.testing.expect;
-const arch = builtin.cpu.arch;
-const is_test = builtin.is_test;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    // Integral -> Float Conversion
-
-    // Conversion to f32
-    @export(__floatsisf, .{ .name = "__floatsisf", .linkage = linkage });
-    @export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = linkage });
-
-    @export(__floatundisf, .{ .name = "__floatundisf", .linkage = linkage });
-    @export(__floatdisf, .{ .name = "__floatdisf", .linkage = linkage });
-
-    @export(__floattisf, .{ .name = "__floattisf", .linkage = linkage });
-    @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = linkage });
-
-    // Conversion to f64
-    @export(__floatsidf, .{ .name = "__floatsidf", .linkage = linkage });
-    @export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = linkage });
-
-    @export(__floatdidf, .{ .name = "__floatdidf", .linkage = linkage });
-    @export(__floatundidf, .{ .name = "__floatundidf", .linkage = linkage });
-
-    @export(__floattidf, .{ .name = "__floattidf", .linkage = linkage });
-    @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = linkage });
-
-    // Conversion to f80
-    @export(__floatsixf, .{ .name = "__floatsixf", .linkage = linkage });
-    @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = linkage });
-
-    @export(__floatdixf, .{ .name = "__floatdixf", .linkage = linkage });
-    @export(__floatundixf, .{ .name = "__floatundixf", .linkage = linkage });
-
-    @export(__floattixf, .{ .name = "__floattixf", .linkage = linkage });
-    @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = linkage });
-
-    // Conversion to f128
-    @export(__floatsitf, .{ .name = "__floatsitf", .linkage = linkage });
-    @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = linkage });
-
-    @export(__floatditf, .{ .name = "__floatditf", .linkage = linkage });
-    @export(__floatunditf, .{ .name = "__floatunditf", .linkage = linkage });
-
-    @export(__floattitf, .{ .name = "__floattitf", .linkage = linkage });
-    @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = linkage });
-
-    if (!is_test) {
-        if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = linkage });
-            @export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = linkage });
-            @export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = linkage });
-            @export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = linkage });
-            @export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = linkage });
-            @export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = linkage });
-            @export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = linkage });
-
-            @export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = linkage });
-        }
-
-        if (arch.isPPC() or arch.isPPC64()) {
-            @export(__floatsikf, .{ .name = "__floatsikf", .linkage = linkage });
-            @export(__floatdikf, .{ .name = "__floatdikf", .linkage = linkage });
-            @export(__floatundikf, .{ .name = "__floatundikf", .linkage = linkage });
-            @export(__floatunsikf, .{ .name = "__floatunsikf", .linkage = linkage });
-            @export(__floatuntikf, .{ .name = "__floatuntikf", .linkage = linkage });
-        }
-    }
-}
-
-pub fn floatXiYf(comptime T: type, x: anytype) T {
-    @setRuntimeSafety(is_test);
-
-    if (x == 0) return 0;
-
-    // Various constants whose values follow from the type parameters.
-    // Any reasonable optimizer will fold and propagate all of these.
-    const Z = std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(x)));
-    const uT = std.meta.Int(.unsigned, @bitSizeOf(T));
-    const inf = math.inf(T);
-    const float_bits = @bitSizeOf(T);
-    const int_bits = @bitSizeOf(@TypeOf(x));
-    const exp_bits = math.floatExponentBits(T);
-    const fractional_bits = math.floatFractionalBits(T);
-    const exp_bias = math.maxInt(std.meta.Int(.unsigned, exp_bits - 1));
-    const implicit_bit = if (T != f80) @as(uT, 1) << fractional_bits else 0;
-    const max_exp = exp_bias;
-
-    // Sign
-    var abs_val = math.absCast(x);
-    const sign_bit = if (x < 0) @as(uT, 1) << (float_bits - 1) else 0;
-    var result: uT = sign_bit;
-
-    // Compute significand
-    var exp = int_bits - @clz(Z, abs_val) - 1;
-    if (int_bits <= fractional_bits or exp <= fractional_bits) {
-        const shift_amt = fractional_bits - @intCast(math.Log2Int(uT), exp);
-
-        // Shift up result to line up with the significand - no rounding required
-        result = (@intCast(uT, abs_val) << shift_amt);
-        result ^= implicit_bit; // Remove implicit integer bit
-    } else {
-        var shift_amt = @intCast(math.Log2Int(Z), exp - fractional_bits);
-        const exact_tie: bool = @ctz(Z, abs_val) == shift_amt - 1;
-
-        // Shift down result and remove implicit integer bit
-        result = @intCast(uT, (abs_val >> (shift_amt - 1))) ^ (implicit_bit << 1);
-
-        // Round result, including round-to-even for exact ties
-        result = ((result + 1) >> 1) & ~@as(uT, @boolToInt(exact_tie));
-    }
-
-    // Compute exponent
-    if ((int_bits > max_exp) and (exp > max_exp)) // If exponent too large, overflow to infinity
-        return @bitCast(T, sign_bit | @bitCast(uT, inf));
-
-    result += (@as(uT, exp) + exp_bias) << math.floatMantissaBits(T);
-
-    // If the result included a carry, we need to restore the explicit integer bit
-    if (T == f80) result |= 1 << fractional_bits;
-
-    return @bitCast(T, sign_bit | result);
-}
-
-// Conversion to f16
-pub fn __floatsihf(a: i32) callconv(.C) f16 {
-    return floatXiYf(f16, a);
-}
-
-pub fn __floatunsihf(a: u32) callconv(.C) f16 {
-    return floatXiYf(f16, a);
-}
-
-pub fn __floatdihf(a: i64) callconv(.C) f16 {
-    return floatXiYf(f16, a);
-}
-
-pub fn __floatundihf(a: u64) callconv(.C) f16 {
-    return floatXiYf(f16, a);
-}
-
-pub fn __floattihf(a: i128) callconv(.C) f16 {
-    return floatXiYf(f16, a);
-}
-
-pub fn __floatuntihf(a: u128) callconv(.C) f16 {
-    return floatXiYf(f16, a);
-}
-
-// Conversion to f32
-pub fn __floatsisf(a: i32) callconv(.C) f32 {
-    return floatXiYf(f32, a);
-}
-
-pub fn __floatunsisf(a: u32) callconv(.C) f32 {
-    return floatXiYf(f32, a);
-}
-
-pub fn __floatdisf(a: i64) callconv(.C) f32 {
-    return floatXiYf(f32, a);
-}
-
-pub fn __floatundisf(a: u64) callconv(.C) f32 {
-    return floatXiYf(f32, a);
-}
-
-pub fn __floattisf(a: i128) callconv(.C) f32 {
-    return floatXiYf(f32, a);
-}
-
-pub fn __floatuntisf(a: u128) callconv(.C) f32 {
-    return floatXiYf(f32, a);
-}
-
-// Conversion to f64
-pub fn __floatsidf(a: i32) callconv(.C) f64 {
-    return floatXiYf(f64, a);
-}
-
-pub fn __floatunsidf(a: u32) callconv(.C) f64 {
-    return floatXiYf(f64, a);
-}
-
-pub fn __floatdidf(a: i64) callconv(.C) f64 {
-    return floatXiYf(f64, a);
-}
-
-pub fn __floatundidf(a: u64) callconv(.C) f64 {
-    return floatXiYf(f64, a);
-}
-
-pub fn __floattidf(a: i128) callconv(.C) f64 {
-    return floatXiYf(f64, a);
-}
-
-pub fn __floatuntidf(a: u128) callconv(.C) f64 {
-    return floatXiYf(f64, a);
-}
-
-// Conversion to f80
-pub fn __floatsixf(a: i32) callconv(.C) f80 {
-    return floatXiYf(f80, a);
-}
-
-pub fn __floatunsixf(a: u32) callconv(.C) f80 {
-    return floatXiYf(f80, a);
-}
-
-pub fn __floatdixf(a: i64) callconv(.C) f80 {
-    return floatXiYf(f80, a);
-}
-
-pub fn __floatundixf(a: u64) callconv(.C) f80 {
-    return floatXiYf(f80, a);
-}
-
-pub fn __floattixf(a: i128) callconv(.C) f80 {
-    return floatXiYf(f80, a);
-}
-
-pub fn __floatuntixf(a: u128) callconv(.C) f80 {
-    return floatXiYf(f80, a);
-}
-
-// Conversion to f128
-pub fn __floatsitf(a: i32) callconv(.C) f128 {
-    return floatXiYf(f128, a);
-}
-
-pub fn __floatsikf(a: i32) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __floatsitf, .{a});
-}
-
-pub fn __floatunsitf(a: u32) callconv(.C) f128 {
-    return floatXiYf(f128, a);
-}
-
-pub fn __floatunsikf(a: u32) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __floatunsitf, .{a});
-}
-
-pub fn __floatditf(a: i64) callconv(.C) f128 {
-    return floatXiYf(f128, a);
-}
-
-pub fn __floatdikf(a: i64) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __floatditf, .{a});
-}
-
-pub fn __floatunditf(a: u64) callconv(.C) f128 {
-    return floatXiYf(f128, a);
-}
-
-pub fn __floatundikf(a: u64) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __floatunditf, .{a});
-}
-
-pub fn __floattitf(a: i128) callconv(.C) f128 {
-    return floatXiYf(f128, a);
-}
-
-pub fn __floatuntitf(a: u128) callconv(.C) f128 {
-    return floatXiYf(f128, a);
-}
-
-pub fn __floatuntikf(a: u128) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __floatuntitf, .{a});
-}
-
-// Conversion to f32
-pub fn __aeabi_ui2f(arg: u32) callconv(.AAPCS) f32 {
-    return floatXiYf(f32, arg);
-}
-
-pub fn __aeabi_i2f(arg: i32) callconv(.AAPCS) f32 {
-    return floatXiYf(f32, arg);
-}
-
-pub fn __aeabi_ul2f(arg: u64) callconv(.AAPCS) f32 {
-    return floatXiYf(f32, arg);
-}
-
-pub fn __aeabi_l2f(arg: i64) callconv(.AAPCS) f32 {
-    return floatXiYf(f32, arg);
-}
-
-// Conversion to f64
-pub fn __aeabi_ui2d(arg: u32) callconv(.AAPCS) f64 {
-    return floatXiYf(f64, arg);
-}
-
-pub fn __aeabi_i2d(arg: i32) callconv(.AAPCS) f64 {
-    return floatXiYf(f64, arg);
-}
-
-pub fn __aeabi_ul2d(arg: u64) callconv(.AAPCS) f64 {
-    return floatXiYf(f64, arg);
-}
-
-pub fn __aeabi_l2d(arg: i64) callconv(.AAPCS) f64 {
-    return floatXiYf(f64, arg);
-}
-
-test {
-    _ = @import("floatXiYf_test.zig");
-}
diff --git a/lib/compiler_rt/float_to_int.zig b/lib/compiler_rt/float_to_int.zig
new file mode 100644
index 0000000000000000000000000000000000000000..49d41be442b699297123fd13c59dbd75b259508a
--- /dev/null
+++ b/lib/compiler_rt/float_to_int.zig
@@ -0,0 +1,55 @@
+const Int = @import("std").meta.Int;
+const math = @import("std").math;
+const Log2Int = math.Log2Int;
+
+pub inline fn floatToInt(comptime I: type, a: anytype) I {
+    const F = @TypeOf(a);
+    const float_bits = @typeInfo(F).Float.bits;
+    const int_bits = @typeInfo(I).Int.bits;
+    const rep_t = Int(.unsigned, float_bits);
+    const sig_bits = math.floatMantissaBits(F);
+    const exp_bits = math.floatExponentBits(F);
+    const fractional_bits = math.floatFractionalBits(F);
+
+    const implicit_bit = if (F != f80) (@as(rep_t, 1) << sig_bits) else 0;
+    const max_exp = (1 << (exp_bits - 1));
+    const exp_bias = max_exp - 1;
+    const sig_mask = (@as(rep_t, 1) << sig_bits) - 1;
+
+    // Break a into sign, exponent, significand
+    const a_rep: rep_t = @bitCast(rep_t, a);
+    const negative = (a_rep >> (float_bits - 1)) != 0;
+    const exponent = @intCast(i32, (a_rep << 1) >> (sig_bits + 1)) - exp_bias;
+    const significand: rep_t = (a_rep & sig_mask) | implicit_bit;
+
+    // If the exponent is negative, the result rounds to zero.
+    if (exponent < 0) return 0;
+
+    // If the value is too large for the integer type, saturate.
+    switch (@typeInfo(I).Int.signedness) {
+        .unsigned => {
+            if (negative) return 0;
+            if (@intCast(c_uint, exponent) >= @minimum(int_bits, max_exp)) return math.maxInt(I);
+        },
+        .signed => if (@intCast(c_uint, exponent) >= @minimum(int_bits - 1, max_exp)) {
+            return if (negative) math.minInt(I) else math.maxInt(I);
+        },
+    }
+
+    // If 0 <= exponent < sig_bits, right shift to get the result.
+    // Otherwise, shift left.
+    var result: I = undefined;
+    if (exponent < fractional_bits) {
+        result = @intCast(I, significand >> @intCast(Log2Int(rep_t), fractional_bits - exponent));
+    } else {
+        result = @intCast(I, significand) << @intCast(Log2Int(I), exponent - fractional_bits);
+    }
+
+    if ((@typeInfo(I).Int.signedness == .signed) and negative)
+        return ~result +% 1;
+    return result;
+}
+
+test {
+    _ = @import("float_to_int_test.zig");
+}
diff --git a/lib/compiler_rt/float_to_int_test.zig b/lib/compiler_rt/float_to_int_test.zig
new file mode 100644
index 0000000000000000000000000000000000000000..00ed455609a4d5fbb5624ef9ceaddc13856e210c
--- /dev/null
+++ b/lib/compiler_rt/float_to_int_test.zig
@@ -0,0 +1,948 @@
+const std = @import("std");
+const testing = std.testing;
+const math = std.math;
+const fixXfYi = @import("fixXfYi.zig").fixXfYi;
+
+// Conversion from f32
+const __fixsfsi = @import("fixXfYi.zig").__fixsfsi;
+const __fixunssfsi = @import("fixXfYi.zig").__fixunssfsi;
+const __fixsfdi = @import("fixXfYi.zig").__fixsfdi;
+const __fixunssfdi = @import("fixXfYi.zig").__fixunssfdi;
+const __fixsfti = @import("fixXfYi.zig").__fixsfti;
+const __fixunssfti = @import("fixXfYi.zig").__fixunssfti;
+
+// Conversion from f64
+const __fixdfsi = @import("fixXfYi.zig").__fixdfsi;
+const __fixunsdfsi = @import("fixXfYi.zig").__fixunsdfsi;
+const __fixdfdi = @import("fixXfYi.zig").__fixdfdi;
+const __fixunsdfdi = @import("fixXfYi.zig").__fixunsdfdi;
+const __fixdfti = @import("fixXfYi.zig").__fixdfti;
+const __fixunsdfti = @import("fixXfYi.zig").__fixunsdfti;
+
+// Conversion from f128
+const __fixtfsi = @import("fixXfYi.zig").__fixtfsi;
+const __fixunstfsi = @import("fixXfYi.zig").__fixunstfsi;
+const __fixtfdi = @import("fixXfYi.zig").__fixtfdi;
+const __fixunstfdi = @import("fixXfYi.zig").__fixunstfdi;
+const __fixtfti = @import("fixXfYi.zig").__fixtfti;
+const __fixunstfti = @import("fixXfYi.zig").__fixunstfti;
+
+fn test__fixsfsi(a: f32, expected: i32) !void {
+    const x = __fixsfsi(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunssfsi(a: f32, expected: u32) !void {
+    const x = __fixunssfsi(a);
+    try testing.expect(x == expected);
+}
+
+test "fixsfsi" {
+    try test__fixsfsi(-math.floatMax(f32), math.minInt(i32));
+
+    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
+    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
+
+    try test__fixsfsi(-0x1.0000000000000p+127, -0x80000000);
+    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
+    try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
+
+    try test__fixsfsi(-0x1.0000000000001p+63, -0x80000000);
+    try test__fixsfsi(-0x1.0000000000000p+63, -0x80000000);
+    try test__fixsfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
+    try test__fixsfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
+
+    try test__fixsfsi(-0x1.FFFFFEp+62, -0x80000000);
+    try test__fixsfsi(-0x1.FFFFFCp+62, -0x80000000);
+
+    try test__fixsfsi(-0x1.000000p+31, -0x80000000);
+    try test__fixsfsi(-0x1.FFFFFFp+30, -0x80000000);
+    try test__fixsfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+    try test__fixsfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+    try test__fixsfsi(-2.01, -2);
+    try test__fixsfsi(-2.0, -2);
+    try test__fixsfsi(-1.99, -1);
+    try test__fixsfsi(-1.0, -1);
+    try test__fixsfsi(-0.99, 0);
+    try test__fixsfsi(-0.5, 0);
+    try test__fixsfsi(-math.floatMin(f32), 0);
+    try test__fixsfsi(0.0, 0);
+    try test__fixsfsi(math.floatMin(f32), 0);
+    try test__fixsfsi(0.5, 0);
+    try test__fixsfsi(0.99, 0);
+    try test__fixsfsi(1.0, 1);
+    try test__fixsfsi(1.5, 1);
+    try test__fixsfsi(1.99, 1);
+    try test__fixsfsi(2.0, 2);
+    try test__fixsfsi(2.01, 2);
+
+    try test__fixsfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+    try test__fixsfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+    try test__fixsfsi(0x1.FFFFFFp+30, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.000000p+31, 0x7FFFFFFF);
+
+    try test__fixsfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
+
+    try test__fixsfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
+
+    try test__fixsfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
+
+    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
+    try test__fixsfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
+
+    try test__fixsfsi(math.floatMax(f32), math.maxInt(i32));
+}
+
+test "fixunssfsi" {
+    try test__fixunssfsi(0.0, 0);
+
+    try test__fixunssfsi(0.5, 0);
+    try test__fixunssfsi(0.99, 0);
+    try test__fixunssfsi(1.0, 1);
+    try test__fixunssfsi(1.5, 1);
+    try test__fixunssfsi(1.99, 1);
+    try test__fixunssfsi(2.0, 2);
+    try test__fixunssfsi(2.01, 2);
+    try test__fixunssfsi(-0.5, 0);
+    try test__fixunssfsi(-0.99, 0);
+
+    try test__fixunssfsi(-1.0, 0);
+    try test__fixunssfsi(-1.5, 0);
+    try test__fixunssfsi(-1.99, 0);
+    try test__fixunssfsi(-2.0, 0);
+    try test__fixunssfsi(-2.01, 0);
+
+    try test__fixunssfsi(0x1.000000p+31, 0x80000000);
+    try test__fixunssfsi(0x1.000000p+32, 0xFFFFFFFF);
+    try test__fixunssfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
+    try test__fixunssfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+    try test__fixunssfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+
+    try test__fixunssfsi(-0x1.FFFFFEp+30, 0);
+    try test__fixunssfsi(-0x1.FFFFFCp+30, 0);
+}
+
+fn test__fixsfdi(a: f32, expected: i64) !void {
+    const x = __fixsfdi(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunssfdi(a: f32, expected: u64) !void {
+    const x = __fixunssfdi(a);
+    try testing.expect(x == expected);
+}
+
+test "fixsfdi" {
+    try test__fixsfdi(-math.floatMax(f32), math.minInt(i64));
+
+    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
+    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
+
+    try test__fixsfdi(-0x1.0000000000000p+127, -0x8000000000000000);
+    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
+    try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
+
+    try test__fixsfdi(-0x1.0000000000001p+63, -0x8000000000000000);
+    try test__fixsfdi(-0x1.0000000000000p+63, -0x8000000000000000);
+    try test__fixsfdi(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
+    try test__fixsfdi(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
+
+    try test__fixsfdi(-0x1.FFFFFFp+62, -0x8000000000000000);
+    try test__fixsfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+    try test__fixsfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+    try test__fixsfdi(-2.01, -2);
+    try test__fixsfdi(-2.0, -2);
+    try test__fixsfdi(-1.99, -1);
+    try test__fixsfdi(-1.0, -1);
+    try test__fixsfdi(-0.99, 0);
+    try test__fixsfdi(-0.5, 0);
+    try test__fixsfdi(-math.floatMin(f32), 0);
+    try test__fixsfdi(0.0, 0);
+    try test__fixsfdi(math.floatMin(f32), 0);
+    try test__fixsfdi(0.5, 0);
+    try test__fixsfdi(0.99, 0);
+    try test__fixsfdi(1.0, 1);
+    try test__fixsfdi(1.5, 1);
+    try test__fixsfdi(1.99, 1);
+    try test__fixsfdi(2.0, 2);
+    try test__fixsfdi(2.01, 2);
+
+    try test__fixsfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+    try test__fixsfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+    try test__fixsfdi(0x1.FFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
+
+    try test__fixsfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFFFFF);
+    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFFFF);
+    try test__fixsfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
+    try test__fixsfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
+
+    try test__fixsfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
+    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
+    try test__fixsfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
+
+    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
+    try test__fixsfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
+
+    try test__fixsfdi(math.floatMax(f32), math.maxInt(i64));
+}
+
+test "fixunssfdi" {
+    try test__fixunssfdi(0.0, 0);
+
+    try test__fixunssfdi(0.5, 0);
+    try test__fixunssfdi(0.99, 0);
+    try test__fixunssfdi(1.0, 1);
+    try test__fixunssfdi(1.5, 1);
+    try test__fixunssfdi(1.99, 1);
+    try test__fixunssfdi(2.0, 2);
+    try test__fixunssfdi(2.01, 2);
+    try test__fixunssfdi(-0.5, 0);
+    try test__fixunssfdi(-0.99, 0);
+
+    try test__fixunssfdi(-1.0, 0);
+    try test__fixunssfdi(-1.5, 0);
+    try test__fixunssfdi(-1.99, 0);
+    try test__fixunssfdi(-2.0, 0);
+    try test__fixunssfdi(-2.01, 0);
+
+    try test__fixunssfdi(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
+    try test__fixunssfdi(0x1.000000p+63, 0x8000000000000000);
+    try test__fixunssfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+    try test__fixunssfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+    try test__fixunssfdi(-0x1.FFFFFEp+62, 0x0000000000000000);
+    try test__fixunssfdi(-0x1.FFFFFCp+62, 0x0000000000000000);
+}
+
+fn test__fixsfti(a: f32, expected: i128) !void {
+    const x = __fixsfti(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunssfti(a: f32, expected: u128) !void {
+    const x = __fixunssfti(a);
+    try testing.expect(x == expected);
+}
+
+test "fixsfti" {
+    try test__fixsfti(-math.floatMax(f32), math.minInt(i128));
+
+    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
+    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
+
+    try test__fixsfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
+    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+126, -0x80000000000000000000000000000000);
+    try test__fixsfti(-0x1.FFFFFFFFFFFFEp+126, -0x80000000000000000000000000000000);
+    try test__fixsfti(-0x1.FFFFFF0000000p+126, -0x80000000000000000000000000000000);
+    try test__fixsfti(-0x1.FFFFFE0000000p+126, -0x7FFFFF80000000000000000000000000);
+    try test__fixsfti(-0x1.FFFFFC0000000p+126, -0x7FFFFF00000000000000000000000000);
+
+    try test__fixsfti(-0x1.0000000000001p+63, -0x8000000000000000);
+    try test__fixsfti(-0x1.0000000000000p+63, -0x8000000000000000);
+    try test__fixsfti(-0x1.FFFFFFFFFFFFFp+62, -0x8000000000000000);
+    try test__fixsfti(-0x1.FFFFFFFFFFFFEp+62, -0x8000000000000000);
+
+    try test__fixsfti(-0x1.FFFFFFp+62, -0x8000000000000000);
+    try test__fixsfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+    try test__fixsfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+    try test__fixsfti(-0x1.000000p+31, -0x80000000);
+    try test__fixsfti(-0x1.FFFFFFp+30, -0x80000000);
+    try test__fixsfti(-0x1.FFFFFEp+30, -0x7FFFFF80);
+    try test__fixsfti(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+    try test__fixsfti(-2.01, -2);
+    try test__fixsfti(-2.0, -2);
+    try test__fixsfti(-1.99, -1);
+    try test__fixsfti(-1.0, -1);
+    try test__fixsfti(-0.99, 0);
+    try test__fixsfti(-0.5, 0);
+    try test__fixsfti(-math.floatMin(f32), 0);
+    try test__fixsfti(0.0, 0);
+    try test__fixsfti(math.floatMin(f32), 0);
+    try test__fixsfti(0.5, 0);
+    try test__fixsfti(0.99, 0);
+    try test__fixsfti(1.0, 1);
+    try test__fixsfti(1.5, 1);
+    try test__fixsfti(1.99, 1);
+    try test__fixsfti(2.0, 2);
+    try test__fixsfti(2.01, 2);
+
+    try test__fixsfti(0x1.FFFFFCp+30, 0x7FFFFF00);
+    try test__fixsfti(0x1.FFFFFEp+30, 0x7FFFFF80);
+    try test__fixsfti(0x1.FFFFFFp+30, 0x80000000);
+    try test__fixsfti(0x1.000000p+31, 0x80000000);
+
+    try test__fixsfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+    try test__fixsfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+    try test__fixsfti(0x1.FFFFFFp+62, 0x8000000000000000);
+
+    try test__fixsfti(0x1.FFFFFFFFFFFFEp+62, 0x8000000000000000);
+    try test__fixsfti(0x1.FFFFFFFFFFFFFp+62, 0x8000000000000000);
+    try test__fixsfti(0x1.0000000000000p+63, 0x8000000000000000);
+    try test__fixsfti(0x1.0000000000001p+63, 0x8000000000000000);
+
+    try test__fixsfti(0x1.FFFFFC0000000p+126, 0x7FFFFF00000000000000000000000000);
+    try test__fixsfti(0x1.FFFFFE0000000p+126, 0x7FFFFF80000000000000000000000000);
+    try test__fixsfti(0x1.FFFFFF0000000p+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    try test__fixsfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    try test__fixsfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    try test__fixsfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+    try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    try test__fixsfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
+
+    try test__fixsfti(math.floatMax(f32), math.maxInt(i128));
+}
+
+test "fixunssfti" {
+    try test__fixunssfti(0.0, 0);
+
+    try test__fixunssfti(0.5, 0);
+    try test__fixunssfti(0.99, 0);
+    try test__fixunssfti(1.0, 1);
+    try test__fixunssfti(1.5, 1);
+    try test__fixunssfti(1.99, 1);
+    try test__fixunssfti(2.0, 2);
+    try test__fixunssfti(2.01, 2);
+    try test__fixunssfti(-0.5, 0);
+    try test__fixunssfti(-0.99, 0);
+
+    try test__fixunssfti(-1.0, 0);
+    try test__fixunssfti(-1.5, 0);
+    try test__fixunssfti(-1.99, 0);
+    try test__fixunssfti(-2.0, 0);
+    try test__fixunssfti(-2.01, 0);
+
+    try test__fixunssfti(0x1.FFFFFEp+63, 0xFFFFFF0000000000);
+    try test__fixunssfti(0x1.000000p+63, 0x8000000000000000);
+    try test__fixunssfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+    try test__fixunssfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+    try test__fixunssfti(0x1.FFFFFEp+127, 0xFFFFFF00000000000000000000000000);
+    try test__fixunssfti(0x1.000000p+127, 0x80000000000000000000000000000000);
+    try test__fixunssfti(0x1.FFFFFEp+126, 0x7FFFFF80000000000000000000000000);
+    try test__fixunssfti(0x1.FFFFFCp+126, 0x7FFFFF00000000000000000000000000);
+
+    try test__fixunssfti(-0x1.FFFFFEp+62, 0x0000000000000000);
+    try test__fixunssfti(-0x1.FFFFFCp+62, 0x0000000000000000);
+    try test__fixunssfti(-0x1.FFFFFEp+126, 0x0000000000000000);
+    try test__fixunssfti(-0x1.FFFFFCp+126, 0x0000000000000000);
+    try test__fixunssfti(math.floatMax(f32), 0xffffff00000000000000000000000000);
+    try test__fixunssfti(math.inf(f32), math.maxInt(u128));
+}
+
+fn test__fixdfsi(a: f64, expected: i32) !void {
+    const x = __fixdfsi(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunsdfsi(a: f64, expected: u32) !void {
+    const x = __fixunsdfsi(a);
+    try testing.expect(x == expected);
+}
+
+test "fixdfsi" {
+    try test__fixdfsi(-math.floatMax(f64), math.minInt(i32));
+
+    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
+    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
+
+    try test__fixdfsi(-0x1.0000000000000p+127, -0x80000000);
+    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
+    try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
+
+    try test__fixdfsi(-0x1.0000000000001p+63, -0x80000000);
+    try test__fixdfsi(-0x1.0000000000000p+63, -0x80000000);
+    try test__fixdfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
+    try test__fixdfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
+
+    try test__fixdfsi(-0x1.FFFFFEp+62, -0x80000000);
+    try test__fixdfsi(-0x1.FFFFFCp+62, -0x80000000);
+
+    try test__fixdfsi(-0x1.000000p+31, -0x80000000);
+    try test__fixdfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
+    try test__fixdfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+
+    try test__fixdfsi(-2.01, -2);
+    try test__fixdfsi(-2.0, -2);
+    try test__fixdfsi(-1.99, -1);
+    try test__fixdfsi(-1.0, -1);
+    try test__fixdfsi(-0.99, 0);
+    try test__fixdfsi(-0.5, 0);
+    try test__fixdfsi(-math.floatMin(f64), 0);
+    try test__fixdfsi(0.0, 0);
+    try test__fixdfsi(math.floatMin(f64), 0);
+    try test__fixdfsi(0.5, 0);
+    try test__fixdfsi(0.99, 0);
+    try test__fixdfsi(1.0, 1);
+    try test__fixdfsi(1.5, 1);
+    try test__fixdfsi(1.99, 1);
+    try test__fixdfsi(2.0, 2);
+    try test__fixdfsi(2.01, 2);
+
+    try test__fixdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+    try test__fixdfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
+    try test__fixdfsi(0x1.000000p+31, 0x7FFFFFFF);
+
+    try test__fixdfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
+    try test__fixdfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
+
+    try test__fixdfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
+    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
+    try test__fixdfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
+    try test__fixdfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
+
+    try test__fixdfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
+    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
+    try test__fixdfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
+
+    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
+    try test__fixdfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
+
+    try test__fixdfsi(math.floatMax(f64), math.maxInt(i32));
+}
+
+test "fixunsdfsi" {
+    try test__fixunsdfsi(0.0, 0);
+
+    try test__fixunsdfsi(0.5, 0);
+    try test__fixunsdfsi(0.99, 0);
+    try test__fixunsdfsi(1.0, 1);
+    try test__fixunsdfsi(1.5, 1);
+    try test__fixunsdfsi(1.99, 1);
+    try test__fixunsdfsi(2.0, 2);
+    try test__fixunsdfsi(2.01, 2);
+    try test__fixunsdfsi(-0.5, 0);
+    try test__fixunsdfsi(-0.99, 0);
+    try test__fixunsdfsi(-1.0, 0);
+    try test__fixunsdfsi(-1.5, 0);
+    try test__fixunsdfsi(-1.99, 0);
+    try test__fixunsdfsi(-2.0, 0);
+    try test__fixunsdfsi(-2.01, 0);
+
+    try test__fixunsdfsi(0x1.000000p+31, 0x80000000);
+    try test__fixunsdfsi(0x1.000000p+32, 0xFFFFFFFF);
+    try test__fixunsdfsi(0x1.FFFFFEp+31, 0xFFFFFF00);
+    try test__fixunsdfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+    try test__fixunsdfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+
+    try test__fixunsdfsi(-0x1.FFFFFEp+30, 0);
+    try test__fixunsdfsi(-0x1.FFFFFCp+30, 0);
+
+    try test__fixunsdfsi(0x1.FFFFFFFEp+31, 0xFFFFFFFF);
+    try test__fixunsdfsi(0x1.FFFFFFFC00000p+30, 0x7FFFFFFF);
+    try test__fixunsdfsi(0x1.FFFFFFF800000p+30, 0x7FFFFFFE);
+}
+
+fn test__fixdfdi(a: f64, expected: i64) !void {
+    const x = __fixdfdi(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunsdfdi(a: f64, expected: u64) !void {
+    const x = __fixunsdfdi(a);
+    try testing.expect(x == expected);
+}
+
+test "fixdfdi" {
+    try test__fixdfdi(-math.floatMax(f64), math.minInt(i64));
+
+    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
+    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
+
+    try test__fixdfdi(-0x1.0000000000000p+127, -0x8000000000000000);
+    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
+    try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
+
+    try test__fixdfdi(-0x1.0000000000001p+63, -0x8000000000000000);
+    try test__fixdfdi(-0x1.0000000000000p+63, -0x8000000000000000);
+    try test__fixdfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+    try test__fixdfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+    try test__fixdfdi(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+    try test__fixdfdi(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+    try test__fixdfdi(-2.01, -2);
+    try test__fixdfdi(-2.0, -2);
+    try test__fixdfdi(-1.99, -1);
+    try test__fixdfdi(-1.0, -1);
+    try test__fixdfdi(-0.99, 0);
+    try test__fixdfdi(-0.5, 0);
+    try test__fixdfdi(-math.floatMin(f64), 0);
+    try test__fixdfdi(0.0, 0);
+    try test__fixdfdi(math.floatMin(f64), 0);
+    try test__fixdfdi(0.5, 0);
+    try test__fixdfdi(0.99, 0);
+    try test__fixdfdi(1.0, 1);
+    try test__fixdfdi(1.5, 1);
+    try test__fixdfdi(1.99, 1);
+    try test__fixdfdi(2.0, 2);
+    try test__fixdfdi(2.01, 2);
+
+    try test__fixdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+    try test__fixdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+    try test__fixdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+    try test__fixdfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
+    try test__fixdfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
+
+    try test__fixdfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
+    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
+    try test__fixdfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
+
+    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
+    try test__fixdfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
+
+    try test__fixdfdi(math.floatMax(f64), math.maxInt(i64));
+}
+
+test "fixunsdfdi" {
+    try test__fixunsdfdi(0.0, 0);
+    try test__fixunsdfdi(0.5, 0);
+    try test__fixunsdfdi(0.99, 0);
+    try test__fixunsdfdi(1.0, 1);
+    try test__fixunsdfdi(1.5, 1);
+    try test__fixunsdfdi(1.99, 1);
+    try test__fixunsdfdi(2.0, 2);
+    try test__fixunsdfdi(2.01, 2);
+    try test__fixunsdfdi(-0.5, 0);
+    try test__fixunsdfdi(-0.99, 0);
+    try test__fixunsdfdi(-1.0, 0);
+    try test__fixunsdfdi(-1.5, 0);
+    try test__fixunsdfdi(-1.99, 0);
+    try test__fixunsdfdi(-2.0, 0);
+    try test__fixunsdfdi(-2.01, 0);
+
+    try test__fixunsdfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+    try test__fixunsdfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+    try test__fixunsdfdi(-0x1.FFFFFEp+62, 0);
+    try test__fixunsdfdi(-0x1.FFFFFCp+62, 0);
+
+    try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
+    try test__fixunsdfdi(0x1.0000000000000p+63, 0x8000000000000000);
+    try test__fixunsdfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+    try test__fixunsdfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+
+    try test__fixunsdfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
+    try test__fixunsdfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
+}
+
+fn test__fixdfti(a: f64, expected: i128) !void {
+    const x = __fixdfti(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunsdfti(a: f64, expected: u128) !void {
+    const x = __fixunsdfti(a);
+    try testing.expect(x == expected);
+}
+
+test "fixdfti" {
+    try test__fixdfti(-math.floatMax(f64), math.minInt(i128));
+
+    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
+    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
+
+    try test__fixdfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
+    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
+    try test__fixdfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
+
+    try test__fixdfti(-0x1.0000000000001p+63, -0x8000000000000800);
+    try test__fixdfti(-0x1.0000000000000p+63, -0x8000000000000000);
+    try test__fixdfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+    try test__fixdfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+    try test__fixdfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+    try test__fixdfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+    try test__fixdfti(-2.01, -2);
+    try test__fixdfti(-2.0, -2);
+    try test__fixdfti(-1.99, -1);
+    try test__fixdfti(-1.0, -1);
+    try test__fixdfti(-0.99, 0);
+    try test__fixdfti(-0.5, 0);
+    try test__fixdfti(-math.floatMin(f64), 0);
+    try test__fixdfti(0.0, 0);
+    try test__fixdfti(math.floatMin(f64), 0);
+    try test__fixdfti(0.5, 0);
+    try test__fixdfti(0.99, 0);
+    try test__fixdfti(1.0, 1);
+    try test__fixdfti(1.5, 1);
+    try test__fixdfti(1.99, 1);
+    try test__fixdfti(2.0, 2);
+    try test__fixdfti(2.01, 2);
+
+    try test__fixdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+    try test__fixdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+    try test__fixdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+    try test__fixdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+    try test__fixdfti(0x1.0000000000000p+63, 0x8000000000000000);
+    try test__fixdfti(0x1.0000000000001p+63, 0x8000000000000800);
+
+    try test__fixdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
+    try test__fixdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
+    try test__fixdfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+    try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    try test__fixdfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
+
+    try test__fixdfti(math.floatMax(f64), math.maxInt(i128));
+}
+
+test "fixunsdfti" {
+    try test__fixunsdfti(0.0, 0);
+
+    try test__fixunsdfti(0.5, 0);
+    try test__fixunsdfti(0.99, 0);
+    try test__fixunsdfti(1.0, 1);
+    try test__fixunsdfti(1.5, 1);
+    try test__fixunsdfti(1.99, 1);
+    try test__fixunsdfti(2.0, 2);
+    try test__fixunsdfti(2.01, 2);
+    try test__fixunsdfti(-0.5, 0);
+    try test__fixunsdfti(-0.99, 0);
+    try test__fixunsdfti(-1.0, 0);
+    try test__fixunsdfti(-1.5, 0);
+    try test__fixunsdfti(-1.99, 0);
+    try test__fixunsdfti(-2.0, 0);
+    try test__fixunsdfti(-2.01, 0);
+
+    try test__fixunsdfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+    try test__fixunsdfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+    try test__fixunsdfti(-0x1.FFFFFEp+62, 0);
+    try test__fixunsdfti(-0x1.FFFFFCp+62, 0);
+
+    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+63, 0xFFFFFFFFFFFFF800);
+    try test__fixunsdfti(0x1.0000000000000p+63, 0x8000000000000000);
+    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+    try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+
+    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+127, 0xFFFFFFFFFFFFF8000000000000000000);
+    try test__fixunsdfti(0x1.0000000000000p+127, 0x80000000000000000000000000000000);
+    try test__fixunsdfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
+    try test__fixunsdfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
+    try test__fixunsdfti(0x1.0000000000000p+128, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+    try test__fixunsdfti(-0x1.FFFFFFFFFFFFFp+62, 0);
+    try test__fixunsdfti(-0x1.FFFFFFFFFFFFEp+62, 0);
+}
+
+fn test__fixtfsi(a: f128, expected: i32) !void {
+    const x = __fixtfsi(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunstfsi(a: f128, expected: u32) !void {
+    const x = __fixunstfsi(a);
+    try testing.expect(x == expected);
+}
+
+test "fixtfsi" {
+    try test__fixtfsi(-math.floatMax(f128), math.minInt(i32));
+
+    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i32));
+    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000);
+
+    try test__fixtfsi(-0x1.0000000000000p+127, -0x80000000);
+    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+126, -0x80000000);
+    try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+126, -0x80000000);
+
+    try test__fixtfsi(-0x1.0000000000001p+63, -0x80000000);
+    try test__fixtfsi(-0x1.0000000000000p+63, -0x80000000);
+    try test__fixtfsi(-0x1.FFFFFFFFFFFFFp+62, -0x80000000);
+    try test__fixtfsi(-0x1.FFFFFFFFFFFFEp+62, -0x80000000);
+
+    try test__fixtfsi(-0x1.FFFFFEp+62, -0x80000000);
+    try test__fixtfsi(-0x1.FFFFFCp+62, -0x80000000);
+
+    try test__fixtfsi(-0x1.000000p+31, -0x80000000);
+    try test__fixtfsi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
+    try test__fixtfsi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+    try test__fixtfsi(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+    try test__fixtfsi(-2.01, -2);
+    try test__fixtfsi(-2.0, -2);
+    try test__fixtfsi(-1.99, -1);
+    try test__fixtfsi(-1.0, -1);
+    try test__fixtfsi(-0.99, 0);
+    try test__fixtfsi(-0.5, 0);
+    try test__fixtfsi(-math.floatMin(f32), 0);
+    try test__fixtfsi(0.0, 0);
+    try test__fixtfsi(math.floatMin(f32), 0);
+    try test__fixtfsi(0.5, 0);
+    try test__fixtfsi(0.99, 0);
+    try test__fixtfsi(1.0, 1);
+    try test__fixtfsi(1.5, 1);
+    try test__fixtfsi(1.99, 1);
+    try test__fixtfsi(2.0, 2);
+    try test__fixtfsi(2.01, 2);
+
+    try test__fixtfsi(0x1.FFFFFCp+30, 0x7FFFFF00);
+    try test__fixtfsi(0x1.FFFFFEp+30, 0x7FFFFF80);
+    try test__fixtfsi(0x1.FFFFFFp+30, 0x7FFFFFC0);
+    try test__fixtfsi(0x1.000000p+31, 0x7FFFFFFF);
+
+    try test__fixtfsi(0x1.FFFFFCp+62, 0x7FFFFFFF);
+    try test__fixtfsi(0x1.FFFFFEp+62, 0x7FFFFFFF);
+
+    try test__fixtfsi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFF);
+    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFF);
+    try test__fixtfsi(0x1.0000000000000p+63, 0x7FFFFFFF);
+    try test__fixtfsi(0x1.0000000000001p+63, 0x7FFFFFFF);
+
+    try test__fixtfsi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFF);
+    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFF);
+    try test__fixtfsi(0x1.0000000000000p+127, 0x7FFFFFFF);
+
+    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFF);
+    try test__fixtfsi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i32));
+
+    try test__fixtfsi(math.floatMax(f128), math.maxInt(i32));
+}
+
+test "fixunstfsi" {
+    try test__fixunstfsi(math.inf(f128), 0xffffffff);
+    try test__fixunstfsi(0, 0x0);
+    try test__fixunstfsi(0x1.23456789abcdefp+5, 0x24);
+    try test__fixunstfsi(0x1.23456789abcdefp-3, 0x0);
+    try test__fixunstfsi(0x1.23456789abcdefp+20, 0x123456);
+    try test__fixunstfsi(0x1.23456789abcdefp+40, 0xffffffff);
+    try test__fixunstfsi(0x1.23456789abcdefp+256, 0xffffffff);
+    try test__fixunstfsi(-0x1.23456789abcdefp+3, 0x0);
+
+    try test__fixunstfsi(0x1p+32, 0xFFFFFFFF);
+}
+
+fn test__fixtfdi(a: f128, expected: i64) !void {
+    const x = __fixtfdi(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunstfdi(a: f128, expected: u64) !void {
+    const x = __fixunstfdi(a);
+    try testing.expect(x == expected);
+}
+
+test "fixtfdi" {
+    try test__fixtfdi(-math.floatMax(f128), math.minInt(i64));
+
+    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i64));
+    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+1023, -0x8000000000000000);
+
+    try test__fixtfdi(-0x1.0000000000000p+127, -0x8000000000000000);
+    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+126, -0x8000000000000000);
+    try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+126, -0x8000000000000000);
+
+    try test__fixtfdi(-0x1.0000000000001p+63, -0x8000000000000000);
+    try test__fixtfdi(-0x1.0000000000000p+63, -0x8000000000000000);
+    try test__fixtfdi(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+    try test__fixtfdi(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+    try test__fixtfdi(-0x1.FFFFFEp+62, -0x7FFFFF8000000000);
+    try test__fixtfdi(-0x1.FFFFFCp+62, -0x7FFFFF0000000000);
+
+    try test__fixtfdi(-0x1.000000p+31, -0x80000000);
+    try test__fixtfdi(-0x1.FFFFFFp+30, -0x7FFFFFC0);
+    try test__fixtfdi(-0x1.FFFFFEp+30, -0x7FFFFF80);
+    try test__fixtfdi(-0x1.FFFFFCp+30, -0x7FFFFF00);
+
+    try test__fixtfdi(-2.01, -2);
+    try test__fixtfdi(-2.0, -2);
+    try test__fixtfdi(-1.99, -1);
+    try test__fixtfdi(-1.0, -1);
+    try test__fixtfdi(-0.99, 0);
+    try test__fixtfdi(-0.5, 0);
+    try test__fixtfdi(-math.floatMin(f64), 0);
+    try test__fixtfdi(0.0, 0);
+    try test__fixtfdi(math.floatMin(f64), 0);
+    try test__fixtfdi(0.5, 0);
+    try test__fixtfdi(0.99, 0);
+    try test__fixtfdi(1.0, 1);
+    try test__fixtfdi(1.5, 1);
+    try test__fixtfdi(1.99, 1);
+    try test__fixtfdi(2.0, 2);
+    try test__fixtfdi(2.01, 2);
+
+    try test__fixtfdi(0x1.FFFFFCp+30, 0x7FFFFF00);
+    try test__fixtfdi(0x1.FFFFFEp+30, 0x7FFFFF80);
+    try test__fixtfdi(0x1.FFFFFFp+30, 0x7FFFFFC0);
+    try test__fixtfdi(0x1.000000p+31, 0x80000000);
+
+    try test__fixtfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+    try test__fixtfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+    try test__fixtfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+    try test__fixtfdi(0x1.0000000000000p+63, 0x7FFFFFFFFFFFFFFF);
+    try test__fixtfdi(0x1.0000000000001p+63, 0x7FFFFFFFFFFFFFFF);
+
+    try test__fixtfdi(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFFFFF);
+    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFFFF);
+    try test__fixtfdi(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFF);
+
+    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFF);
+    try test__fixtfdi(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i64));
+
+    try test__fixtfdi(math.floatMax(f128), math.maxInt(i64));
+}
+
+test "fixunstfdi" {
+    try test__fixunstfdi(0.0, 0);
+
+    try test__fixunstfdi(0.5, 0);
+    try test__fixunstfdi(0.99, 0);
+    try test__fixunstfdi(1.0, 1);
+    try test__fixunstfdi(1.5, 1);
+    try test__fixunstfdi(1.99, 1);
+    try test__fixunstfdi(2.0, 2);
+    try test__fixunstfdi(2.01, 2);
+    try test__fixunstfdi(-0.5, 0);
+    try test__fixunstfdi(-0.99, 0);
+    try test__fixunstfdi(-1.0, 0);
+    try test__fixunstfdi(-1.5, 0);
+    try test__fixunstfdi(-1.99, 0);
+    try test__fixunstfdi(-2.0, 0);
+    try test__fixunstfdi(-2.01, 0);
+
+    try test__fixunstfdi(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+    try test__fixunstfdi(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+
+    try test__fixunstfdi(-0x1.FFFFFEp+62, 0);
+    try test__fixunstfdi(-0x1.FFFFFCp+62, 0);
+
+    try test__fixunstfdi(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+    try test__fixunstfdi(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+
+    try test__fixunstfdi(-0x1.FFFFFFFFFFFFFp+62, 0);
+    try test__fixunstfdi(-0x1.FFFFFFFFFFFFEp+62, 0);
+
+    try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFEp+63, 0xFFFFFFFFFFFFFFFF);
+    try test__fixunstfdi(0x1.0000000000000002p+63, 0x8000000000000001);
+    try test__fixunstfdi(0x1.0000000000000000p+63, 0x8000000000000000);
+    try test__fixunstfdi(0x1.FFFFFFFFFFFFFFFCp+62, 0x7FFFFFFFFFFFFFFF);
+    try test__fixunstfdi(0x1.FFFFFFFFFFFFFFF8p+62, 0x7FFFFFFFFFFFFFFE);
+    try test__fixunstfdi(0x1p+64, 0xFFFFFFFFFFFFFFFF);
+
+    try test__fixunstfdi(-0x1.0000000000000000p+63, 0);
+    try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFFCp+62, 0);
+    try test__fixunstfdi(-0x1.FFFFFFFFFFFFFFF8p+62, 0);
+}
+
+fn test__fixtfti(a: f128, expected: i128) !void {
+    const x = __fixtfti(a);
+    try testing.expect(x == expected);
+}
+
+fn test__fixunstfti(a: f128, expected: u128) !void {
+    const x = __fixunstfti(a);
+    try testing.expect(x == expected);
+}
+
+test "fixtfti" {
+    try test__fixtfti(-math.floatMax(f128), math.minInt(i128));
+
+    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, math.minInt(i128));
+    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+1023, -0x80000000000000000000000000000000);
+
+    try test__fixtfti(-0x1.0000000000000p+127, -0x80000000000000000000000000000000);
+    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+126, -0x7FFFFFFFFFFFFC000000000000000000);
+    try test__fixtfti(-0x1.FFFFFFFFFFFFEp+126, -0x7FFFFFFFFFFFF8000000000000000000);
+
+    try test__fixtfti(-0x1.0000000000001p+63, -0x8000000000000800);
+    try test__fixtfti(-0x1.0000000000000p+63, -0x8000000000000000);
+    try test__fixtfti(-0x1.FFFFFFFFFFFFFp+62, -0x7FFFFFFFFFFFFC00);
+    try test__fixtfti(-0x1.FFFFFFFFFFFFEp+62, -0x7FFFFFFFFFFFF800);
+
+    try test__fixtfti(-0x1.FFFFFEp+62, -0x7fffff8000000000);
+    try test__fixtfti(-0x1.FFFFFCp+62, -0x7fffff0000000000);
+
+    try test__fixtfti(-2.01, -2);
+    try test__fixtfti(-2.0, -2);
+    try test__fixtfti(-1.99, -1);
+    try test__fixtfti(-1.0, -1);
+    try test__fixtfti(-0.99, 0);
+    try test__fixtfti(-0.5, 0);
+    try test__fixtfti(-math.floatMin(f128), 0);
+    try test__fixtfti(0.0, 0);
+    try test__fixtfti(math.floatMin(f128), 0);
+    try test__fixtfti(0.5, 0);
+    try test__fixtfti(0.99, 0);
+    try test__fixtfti(1.0, 1);
+    try test__fixtfti(1.5, 1);
+    try test__fixtfti(1.99, 1);
+    try test__fixtfti(2.0, 2);
+    try test__fixtfti(2.01, 2);
+
+    try test__fixtfti(0x1.FFFFFCp+62, 0x7FFFFF0000000000);
+    try test__fixtfti(0x1.FFFFFEp+62, 0x7FFFFF8000000000);
+
+    try test__fixtfti(0x1.FFFFFFFFFFFFEp+62, 0x7FFFFFFFFFFFF800);
+    try test__fixtfti(0x1.FFFFFFFFFFFFFp+62, 0x7FFFFFFFFFFFFC00);
+    try test__fixtfti(0x1.0000000000000p+63, 0x8000000000000000);
+    try test__fixtfti(0x1.0000000000001p+63, 0x8000000000000800);
+
+    try test__fixtfti(0x1.FFFFFFFFFFFFEp+126, 0x7FFFFFFFFFFFF8000000000000000000);
+    try test__fixtfti(0x1.FFFFFFFFFFFFFp+126, 0x7FFFFFFFFFFFFC000000000000000000);
+    try test__fixtfti(0x1.0000000000000p+127, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+
+    try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
+    try test__fixtfti(0x1.FFFFFFFFFFFFFp+1023, math.maxInt(i128));
+
+    try test__fixtfti(math.floatMax(f128), math.maxInt(i128));
+}
+
+test "fixunstfti" {
+    try test__fixunstfti(math.inf(f128), 0xffffffffffffffffffffffffffffffff);
+
+    try test__fixunstfti(0.0, 0);
+
+    try test__fixunstfti(0.5, 0);
+    try test__fixunstfti(0.99, 0);
+    try test__fixunstfti(1.0, 1);
+    try test__fixunstfti(1.5, 1);
+    try test__fixunstfti(1.99, 1);
+    try test__fixunstfti(2.0, 2);
+    try test__fixunstfti(2.01, 2);
+    try test__fixunstfti(-0.01, 0);
+    try test__fixunstfti(-0.99, 0);
+
+    try test__fixunstfti(0x1p+128, 0xffffffffffffffffffffffffffffffff);
+
+    try test__fixunstfti(0x1.FFFFFEp+126, 0x7fffff80000000000000000000000000);
+    try test__fixunstfti(0x1.FFFFFEp+127, 0xffffff00000000000000000000000000);
+    try test__fixunstfti(0x1.FFFFFEp+128, 0xffffffffffffffffffffffffffffffff);
+    try test__fixunstfti(0x1.FFFFFEp+129, 0xffffffffffffffffffffffffffffffff);
+}
+
+fn test__fixunshfti(a: f16, expected: u128) !void {
+    const x = fixXfYi(u128, a);
+    try testing.expect(x == expected);
+}
+
+test "fixXfYi for f16" {
+    try test__fixunshfti(math.inf(f16), math.maxInt(u128));
+    try test__fixunshfti(math.floatMax(f16), 65504);
+}
+
+fn test__fixunsxfti(a: f80, expected: u128) !void {
+    const x = fixXfYi(u128, a);
+    try testing.expect(x == expected);
+}
+
+test "fixXfYi for f80" {
+    try test__fixunsxfti(math.inf(f80), math.maxInt(u128));
+    try test__fixunsxfti(math.floatMax(f80), math.maxInt(u128));
+    try test__fixunsxfti(math.maxInt(u64), math.maxInt(u64));
+}
diff --git a/lib/compiler_rt/floatdidf.zig b/lib/compiler_rt/floatdidf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9a0ecc6ed48f3bd8db1131052810a3f4d9722a6a
--- /dev/null
+++ b/lib/compiler_rt/floatdidf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_l2d, .{ .name = "__aeabi_l2d", .linkage = common.linkage });
+    } else {
+        @export(__floatdidf, .{ .name = "__floatdidf", .linkage = common.linkage });
+    }
+}
+
+fn __floatdidf(a: i64) callconv(.C) f64 {
+    return intToFloat(f64, a);
+}
+
+fn __aeabi_l2d(a: i64) callconv(.AAPCS) f64 {
+    return intToFloat(f64, a);
+}
diff --git a/lib/compiler_rt/floatdihf.zig b/lib/compiler_rt/floatdihf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f2f7236d6f42efa284194b387b64347d59b24818
--- /dev/null
+++ b/lib/compiler_rt/floatdihf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatdihf, .{ .name = "__floatdihf", .linkage = common.linkage });
+}
+
+fn __floatdihf(a: i64) callconv(.C) f16 {
+    return intToFloat(f16, a);
+}
diff --git a/lib/compiler_rt/floatdisf.zig b/lib/compiler_rt/floatdisf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..d2ad3bb04b438b955307c8b48e0532eada8e62cd
--- /dev/null
+++ b/lib/compiler_rt/floatdisf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_l2f, .{ .name = "__aeabi_l2f", .linkage = common.linkage });
+    } else {
+        @export(__floatdisf, .{ .name = "__floatdisf", .linkage = common.linkage });
+    }
+}
+
+fn __floatdisf(a: i64) callconv(.C) f32 {
+    return intToFloat(f32, a);
+}
+
+fn __aeabi_l2f(a: i64) callconv(.AAPCS) f32 {
+    return intToFloat(f32, a);
+}
diff --git a/lib/compiler_rt/floatditf.zig b/lib/compiler_rt/floatditf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..04132b9c242aa42c7683eb5810ef7cc9d883bb8b
--- /dev/null
+++ b/lib/compiler_rt/floatditf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__floatdikf, .{ .name = "__floatdikf", .linkage = common.linkage });
+    } else {
+        @export(__floatditf, .{ .name = "__floatditf", .linkage = common.linkage });
+    }
+}
+
+fn __floatditf(a: i64) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
+
+fn __floatdikf(a: i64) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
diff --git a/lib/compiler_rt/floatdixf.zig b/lib/compiler_rt/floatdixf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..7d80fdbeb8983fedde9294a92a777a91b161769b
--- /dev/null
+++ b/lib/compiler_rt/floatdixf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatdixf, .{ .name = "__floatdixf", .linkage = common.linkage });
+}
+
+fn __floatdixf(a: i64) callconv(.C) f80 {
+    return intToFloat(f80, a);
+}
diff --git a/lib/compiler_rt/floatsidf.zig b/lib/compiler_rt/floatsidf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1775b080322136241f423aa785b99843bc9cddcc
--- /dev/null
+++ b/lib/compiler_rt/floatsidf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_i2d, .{ .name = "__aeabi_i2d", .linkage = common.linkage });
+    } else {
+        @export(__floatsidf, .{ .name = "__floatsidf", .linkage = common.linkage });
+    }
+}
+
+fn __floatsidf(a: i32) callconv(.C) f64 {
+    return intToFloat(f64, a);
+}
+
+fn __aeabi_i2d(a: i32) callconv(.AAPCS) f64 {
+    return intToFloat(f64, a);
+}
diff --git a/lib/compiler_rt/floatsihf.zig b/lib/compiler_rt/floatsihf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..84b54298b5ecacec1638540f152455bdb19199ee
--- /dev/null
+++ b/lib/compiler_rt/floatsihf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatsihf, .{ .name = "__floatsihf", .linkage = common.linkage });
+}
+
+fn __floatsihf(a: i32) callconv(.C) f16 {
+    return intToFloat(f16, a);
+}
diff --git a/lib/compiler_rt/floatsisf.zig b/lib/compiler_rt/floatsisf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..45c7f8d6e45a2e88e5bea782e59f04b1fa0e4ea5
--- /dev/null
+++ b/lib/compiler_rt/floatsisf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_i2f, .{ .name = "__aeabi_i2f", .linkage = common.linkage });
+    } else {
+        @export(__floatsisf, .{ .name = "__floatsisf", .linkage = common.linkage });
+    }
+}
+
+fn __floatsisf(a: i32) callconv(.C) f32 {
+    return intToFloat(f32, a);
+}
+
+fn __aeabi_i2f(a: i32) callconv(.AAPCS) f32 {
+    return intToFloat(f32, a);
+}
diff --git a/lib/compiler_rt/floatsitf.zig b/lib/compiler_rt/floatsitf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..24f5e3bf42827044c8393a6ae2c7067d25022e22
--- /dev/null
+++ b/lib/compiler_rt/floatsitf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__floatsikf, .{ .name = "__floatsikf", .linkage = common.linkage });
+    } else {
+        @export(__floatsitf, .{ .name = "__floatsitf", .linkage = common.linkage });
+    }
+}
+
+fn __floatsitf(a: i32) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
+
+fn __floatsikf(a: i32) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
diff --git a/lib/compiler_rt/floatsixf.zig b/lib/compiler_rt/floatsixf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..76d266e17a0aa576a837edabb185f8d61734caa2
--- /dev/null
+++ b/lib/compiler_rt/floatsixf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatsixf, .{ .name = "__floatsixf", .linkage = common.linkage });
+}
+
+fn __floatsixf(a: i32) callconv(.C) f80 {
+    return intToFloat(f80, a);
+}
diff --git a/lib/compiler_rt/floattidf.zig b/lib/compiler_rt/floattidf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..54fff192c7719a56ea876b62ede2e9ffaf090df8
--- /dev/null
+++ b/lib/compiler_rt/floattidf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floattidf, .{ .name = "__floattidf", .linkage = common.linkage });
+}
+
+fn __floattidf(a: i128) callconv(.C) f64 {
+    return intToFloat(f64, a);
+}
diff --git a/lib/compiler_rt/floattihf.zig b/lib/compiler_rt/floattihf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c7e45c7d53718b6ba5b826a980fad789079b090a
--- /dev/null
+++ b/lib/compiler_rt/floattihf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floattihf, .{ .name = "__floattihf", .linkage = common.linkage });
+}
+
+fn __floattihf(a: i128) callconv(.C) f16 {
+    return intToFloat(f16, a);
+}
diff --git a/lib/compiler_rt/floattisf.zig b/lib/compiler_rt/floattisf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bc161d039f4b8b1f8bc3cfdcadb06149432d067f
--- /dev/null
+++ b/lib/compiler_rt/floattisf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floattisf, .{ .name = "__floattisf", .linkage = common.linkage });
+}
+
+fn __floattisf(a: i128) callconv(.C) f32 {
+    return intToFloat(f32, a);
+}
diff --git a/lib/compiler_rt/floattitf.zig b/lib/compiler_rt/floattitf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..bcd75d8d8366917417938d3718cb45a56c6dfb0a
--- /dev/null
+++ b/lib/compiler_rt/floattitf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floattitf, .{ .name = "__floattitf", .linkage = common.linkage });
+}
+
+fn __floattitf(a: i128) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
diff --git a/lib/compiler_rt/floattixf.zig b/lib/compiler_rt/floattixf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..def9bef4d5e0568884f41667163089fb25f6e97d
--- /dev/null
+++ b/lib/compiler_rt/floattixf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floattixf, .{ .name = "__floattixf", .linkage = common.linkage });
+}
+
+fn __floattixf(a: i128) callconv(.C) f80 {
+    return intToFloat(f80, a);
+}
diff --git a/lib/compiler_rt/floatundidf.zig b/lib/compiler_rt/floatundidf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..aed9f42139ad3269683f1a90e963483a51c40356
--- /dev/null
+++ b/lib/compiler_rt/floatundidf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_ul2d, .{ .name = "__aeabi_ul2d", .linkage = common.linkage });
+    } else {
+        @export(__floatundidf, .{ .name = "__floatundidf", .linkage = common.linkage });
+    }
+}
+
+fn __floatundidf(a: u64) callconv(.C) f64 {
+    return intToFloat(f64, a);
+}
+
+fn __aeabi_ul2d(a: u64) callconv(.AAPCS) f64 {
+    return intToFloat(f64, a);
+}
diff --git a/lib/compiler_rt/floatundihf.zig b/lib/compiler_rt/floatundihf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6eff8aaec3a3759262964f906495c774ca3d6544
--- /dev/null
+++ b/lib/compiler_rt/floatundihf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatundihf, .{ .name = "__floatundihf", .linkage = common.linkage });
+}
+
+fn __floatundihf(a: u64) callconv(.C) f16 {
+    return intToFloat(f16, a);
+}
diff --git a/lib/compiler_rt/floatundisf.zig b/lib/compiler_rt/floatundisf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1e6094cead8b286c4841714f17509739dee63b8b
--- /dev/null
+++ b/lib/compiler_rt/floatundisf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_ul2f, .{ .name = "__aeabi_ul2f", .linkage = common.linkage });
+    } else {
+        @export(__floatundisf, .{ .name = "__floatundisf", .linkage = common.linkage });
+    }
+}
+
+fn __floatundisf(a: u64) callconv(.C) f32 {
+    return intToFloat(f32, a);
+}
+
+fn __aeabi_ul2f(a: u64) callconv(.AAPCS) f32 {
+    return intToFloat(f32, a);
+}
diff --git a/lib/compiler_rt/floatunditf.zig b/lib/compiler_rt/floatunditf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..40424d1a6c82476df62bdf91707a186d7e55499d
--- /dev/null
+++ b/lib/compiler_rt/floatunditf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__floatundikf, .{ .name = "__floatundikf", .linkage = common.linkage });
+    } else {
+        @export(__floatunditf, .{ .name = "__floatunditf", .linkage = common.linkage });
+    }
+}
+
+fn __floatunditf(a: u64) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
+
+fn __floatundikf(a: u64) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
diff --git a/lib/compiler_rt/floatundixf.zig b/lib/compiler_rt/floatundixf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..331b74df4f83c127e81a61c5b490f1d6283a9c4b
--- /dev/null
+++ b/lib/compiler_rt/floatundixf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatundixf, .{ .name = "__floatundixf", .linkage = common.linkage });
+}
+
+fn __floatundixf(a: u64) callconv(.C) f80 {
+    return intToFloat(f80, a);
+}
diff --git a/lib/compiler_rt/floatunsidf.zig b/lib/compiler_rt/floatunsidf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..472167841b772a7f9b7e82d8f1b888b655702c18
--- /dev/null
+++ b/lib/compiler_rt/floatunsidf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_ui2d, .{ .name = "__aeabi_ui2d", .linkage = common.linkage });
+    } else {
+        @export(__floatunsidf, .{ .name = "__floatunsidf", .linkage = common.linkage });
+    }
+}
+
+fn __floatunsidf(a: u32) callconv(.C) f64 {
+    return intToFloat(f64, a);
+}
+
+fn __aeabi_ui2d(a: u32) callconv(.AAPCS) f64 {
+    return intToFloat(f64, a);
+}
diff --git a/lib/compiler_rt/floatunsihf.zig b/lib/compiler_rt/floatunsihf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c95de9c53675346d0cc41f919c23f6350eea86dc
--- /dev/null
+++ b/lib/compiler_rt/floatunsihf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatunsihf, .{ .name = "__floatunsihf", .linkage = common.linkage });
+}
+
+fn __floatunsihf(a: u32) callconv(.C) f16 {
+    return intToFloat(f16, a);
+}
diff --git a/lib/compiler_rt/floatunsisf.zig b/lib/compiler_rt/floatunsisf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..b2956e9e282a0a8e287cdd4b3fab4d99a601e004
--- /dev/null
+++ b/lib/compiler_rt/floatunsisf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_ui2f, .{ .name = "__aeabi_ui2f", .linkage = common.linkage });
+    } else {
+        @export(__floatunsisf, .{ .name = "__floatunsisf", .linkage = common.linkage });
+    }
+}
+
+fn __floatunsisf(a: u32) callconv(.C) f32 {
+    return intToFloat(f32, a);
+}
+
+fn __aeabi_ui2f(a: u32) callconv(.AAPCS) f32 {
+    return intToFloat(f32, a);
+}
diff --git a/lib/compiler_rt/floatunsitf.zig b/lib/compiler_rt/floatunsitf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..3f626324d2189c47622ff2023b20bf1c49e8263c
--- /dev/null
+++ b/lib/compiler_rt/floatunsitf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__floatunsikf, .{ .name = "__floatunsikf", .linkage = common.linkage });
+    } else {
+        @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage });
+    }
+}
+
+fn __floatunsitf(a: u32) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
+
+fn __floatunsikf(a: u32) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
diff --git a/lib/compiler_rt/floatunsixf.zig b/lib/compiler_rt/floatunsixf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..40492564fcd66f1d0626f6b7f81ffb11f7164b5a
--- /dev/null
+++ b/lib/compiler_rt/floatunsixf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatunsixf, .{ .name = "__floatunsixf", .linkage = common.linkage });
+}
+
+fn __floatunsixf(a: u32) callconv(.C) f80 {
+    return intToFloat(f80, a);
+}
diff --git a/lib/compiler_rt/floatuntidf.zig b/lib/compiler_rt/floatuntidf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5b35379d3871618818665a301194246613c0bde9
--- /dev/null
+++ b/lib/compiler_rt/floatuntidf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatuntidf, .{ .name = "__floatuntidf", .linkage = common.linkage });
+}
+
+fn __floatuntidf(a: u128) callconv(.C) f64 {
+    return intToFloat(f64, a);
+}
diff --git a/lib/compiler_rt/floatuntihf.zig b/lib/compiler_rt/floatuntihf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0263b1da98bcec268b60490a82039afcd985229a
--- /dev/null
+++ b/lib/compiler_rt/floatuntihf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatuntihf, .{ .name = "__floatuntihf", .linkage = common.linkage });
+}
+
+fn __floatuntihf(a: u128) callconv(.C) f16 {
+    return intToFloat(f16, a);
+}
diff --git a/lib/compiler_rt/floatuntisf.zig b/lib/compiler_rt/floatuntisf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a3799e50b39d4c11e040652a1be20285b3c8feb9
--- /dev/null
+++ b/lib/compiler_rt/floatuntisf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatuntisf, .{ .name = "__floatuntisf", .linkage = common.linkage });
+}
+
+fn __floatuntisf(a: u128) callconv(.C) f32 {
+    return intToFloat(f32, a);
+}
diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c1b4b21d56e9b16db6a4b3c8df11e89c3a672768
--- /dev/null
+++ b/lib/compiler_rt/floatuntitf.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__floatuntikf, .{ .name = "__floatuntikf", .linkage = common.linkage });
+    } else {
+        @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage });
+    }
+}
+
+fn __floatuntitf(a: u128) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
+
+fn __floatuntikf(a: u128) callconv(.C) f128 {
+    return intToFloat(f128, a);
+}
diff --git a/lib/compiler_rt/floatuntixf.zig b/lib/compiler_rt/floatuntixf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..07017d1f573835483c6d0b59ae7e32a343bf3695
--- /dev/null
+++ b/lib/compiler_rt/floatuntixf.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const intToFloat = @import("./int_to_float.zig").intToFloat;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__floatuntixf, .{ .name = "__floatuntixf", .linkage = common.linkage });
+}
+
+pub fn __floatuntixf(a: u128) callconv(.C) f80 {
+    return intToFloat(f80, a);
+}
diff --git a/lib/compiler_rt/gedf2.zig b/lib/compiler_rt/gedf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..816d690fa02a09cb06ad4811a1744d6292fae353
--- /dev/null
+++ b/lib/compiler_rt/gedf2.zig
@@ -0,0 +1,36 @@
+///! The quoted behavior definitions are from
+///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_dcmpge, .{ .name = "__aeabi_dcmpge", .linkage = common.linkage });
+        @export(__aeabi_dcmpgt, .{ .name = "__aeabi_dcmpgt", .linkage = common.linkage });
+    } else {
+        @export(__gedf2, .{ .name = "__gedf2", .linkage = common.linkage });
+        @export(__gtdf2, .{ .name = "__gtdf2", .linkage = common.linkage });
+    }
+}
+
+/// "These functions return a value greater than or equal to zero if neither
+/// argument is NaN, and a is greater than or equal to b."
+fn __gedf2(a: f64, b: f64) callconv(.C) i32 {
+    return @enumToInt(comparef.cmpf2(f64, comparef.GE, a, b));
+}
+
+/// "These functions return a value greater than zero if neither argument is NaN,
+/// and a is strictly greater than b."
+fn __gtdf2(a: f64, b: f64) callconv(.C) i32 {
+    return __gedf2(a, b);
+}
+
+fn __aeabi_dcmpge(a: f64, b: f64) callconv(.AAPCS) i32 {
+    return comparef.cmpf2(f64, comparef.GE, a, b) != .Less;
+}
+
+fn __aeabi_dcmpgt(a: f64, b: f64) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f64, comparef.GE, a, b) == .Greater);
+}
diff --git a/lib/compiler_rt/gesf2.zig b/lib/compiler_rt/gesf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f29cd173a526bd2ec0c837d9b56e970905ef0d65
--- /dev/null
+++ b/lib/compiler_rt/gesf2.zig
@@ -0,0 +1,36 @@
+///! The quoted behavior definitions are from
+///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_fcmpge, .{ .name = "__aeabi_fcmpge", .linkage = common.linkage });
+        @export(__aeabi_fcmpgt, .{ .name = "__aeabi_fcmpgt", .linkage = common.linkage });
+    } else {
+        @export(__gesf2, .{ .name = "__gesf2", .linkage = common.linkage });
+        @export(__gtsf2, .{ .name = "__gtsf2", .linkage = common.linkage });
+    }
+}
+
+/// "These functions return a value greater than or equal to zero if neither
+/// argument is NaN, and a is greater than or equal to b."
+fn __gesf2(a: f32, b: f32) callconv(.C) i32 {
+    return @enumToInt(comparef.cmpf2(f32, comparef.GE, a, b));
+}
+
+/// "These functions return a value greater than zero if neither argument is NaN,
+/// and a is strictly greater than b."
+fn __gtsf2(a: f32, b: f32) callconv(.C) i32 {
+    return __gesf2(a, b);
+}
+
+fn __aeabi_fcmpge(a: f32, b: f32) callconv(.AAPCS) i32 {
+    return comparef.cmpf2(f32, comparef.GE, a, b) != .Less;
+}
+
+fn __aeabi_fcmpgt(a: f32, b: f32) callconv(.AAPCS) i32 {
+    return @boolToInt(comparef.cmpf2(f32, comparef.LE, a, b) == .Greater);
+}
diff --git a/lib/compiler_rt/getf2.zig b/lib/compiler_rt/getf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..402d9ad3911c599a4d18d9df8d13e9d5412d750d
--- /dev/null
+++ b/lib/compiler_rt/getf2.zig
@@ -0,0 +1,36 @@
+///! The quoted behavior definitions are from
+///! https://gcc.gnu.org/onlinedocs/gcc-12.1.0/gccint/Soft-float-library-routines.html#Soft-float-library-routines
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__gekf2, .{ .name = "__gekf2", .linkage = common.linkage });
+        @export(__gtkf2, .{ .name = "__gtkf2", .linkage = common.linkage });
+    } else {
+        @export(__getf2, .{ .name = "__getf2", .linkage = common.linkage });
+        @export(__gttf2, .{ .name = "__gttf2", .linkage = common.linkage });
+    }
+}
+
+/// "These functions return a value greater than or equal to zero if neither
+/// argument is NaN, and a is greater than or equal to b."
+fn __getf2(a: f128, b: f128) callconv(.C) i32 {
+    return @enumToInt(comparef.cmpf2(f128, comparef.GE, a, b));
+}
+
+/// "These functions return a value greater than zero if neither argument is NaN,
+/// and a is strictly greater than b."
+fn __gttf2(a: f128, b: f128) callconv(.C) i32 {
+    return __getf2(a, b);
+}
+
+fn __gekf2(a: f128, b: f128) callconv(.C) i32 {
+    return __getf2(a, b);
+}
+
+fn __gtkf2(a: f128, b: f128) callconv(.C) i32 {
+    return __getf2(a, b);
+}
diff --git a/lib/compiler_rt/gexf2.zig b/lib/compiler_rt/gexf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6bb88fbb8f4ef7fa2b610b8628cb8a5a55dd9353
--- /dev/null
+++ b/lib/compiler_rt/gexf2.zig
@@ -0,0 +1,17 @@
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__gexf2, .{ .name = "__gexf2", .linkage = common.linkage });
+    @export(__gtxf2, .{ .name = "__gtxf2", .linkage = common.linkage });
+}
+
+fn __gexf2(a: f80, b: f80) callconv(.C) i32 {
+    return @enumToInt(comparef.cmp_f80(comparef.GE, a, b));
+}
+
+fn __gtxf2(a: f80, b: f80) callconv(.C) i32 {
+    return __gexf2(a, b);
+}
diff --git a/lib/compiler_rt/int_to_float.zig b/lib/compiler_rt/int_to_float.zig
new file mode 100644
index 0000000000000000000000000000000000000000..135f9e1dbbedc836e950a90ccbff825e234e311b
--- /dev/null
+++ b/lib/compiler_rt/int_to_float.zig
@@ -0,0 +1,58 @@
+const Int = @import("std").meta.Int;
+const math = @import("std").math;
+
+pub fn intToFloat(comptime T: type, x: anytype) T {
+    if (x == 0) return 0;
+
+    // Various constants whose values follow from the type parameters.
+    // Any reasonable optimizer will fold and propagate all of these.
+    const Z = Int(.unsigned, @bitSizeOf(@TypeOf(x)));
+    const uT = Int(.unsigned, @bitSizeOf(T));
+    const inf = math.inf(T);
+    const float_bits = @bitSizeOf(T);
+    const int_bits = @bitSizeOf(@TypeOf(x));
+    const exp_bits = math.floatExponentBits(T);
+    const fractional_bits = math.floatFractionalBits(T);
+    const exp_bias = math.maxInt(Int(.unsigned, exp_bits - 1));
+    const implicit_bit = if (T != f80) @as(uT, 1) << fractional_bits else 0;
+    const max_exp = exp_bias;
+
+    // Sign
+    var abs_val = math.absCast(x);
+    const sign_bit = if (x < 0) @as(uT, 1) << (float_bits - 1) else 0;
+    var result: uT = sign_bit;
+
+    // Compute significand
+    var exp = int_bits - @clz(Z, abs_val) - 1;
+    if (int_bits <= fractional_bits or exp <= fractional_bits) {
+        const shift_amt = fractional_bits - @intCast(math.Log2Int(uT), exp);
+
+        // Shift up result to line up with the significand - no rounding required
+        result = (@intCast(uT, abs_val) << shift_amt);
+        result ^= implicit_bit; // Remove implicit integer bit
+    } else {
+        var shift_amt = @intCast(math.Log2Int(Z), exp - fractional_bits);
+        const exact_tie: bool = @ctz(Z, abs_val) == shift_amt - 1;
+
+        // Shift down result and remove implicit integer bit
+        result = @intCast(uT, (abs_val >> (shift_amt - 1))) ^ (implicit_bit << 1);
+
+        // Round result, including round-to-even for exact ties
+        result = ((result + 1) >> 1) & ~@as(uT, @boolToInt(exact_tie));
+    }
+
+    // Compute exponent
+    if ((int_bits > max_exp) and (exp > max_exp)) // If exponent too large, overflow to infinity
+        return @bitCast(T, sign_bit | @bitCast(uT, inf));
+
+    result += (@as(uT, exp) + exp_bias) << math.floatMantissaBits(T);
+
+    // If the result included a carry, we need to restore the explicit integer bit
+    if (T == f80) result |= 1 << fractional_bits;
+
+    return @bitCast(T, sign_bit | result);
+}
+
+test {
+    _ = @import("floatXiYf_test.zig");
+}
diff --git a/lib/compiler_rt/mulXf3.zig b/lib/compiler_rt/mulXf3.zig
deleted file mode 100644
index dc6ac98407ef08b95a73305775a496a1f0c2ccff..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/mulXf3.zig
+++ /dev/null
@@ -1,368 +0,0 @@
-// Ported from:
-//
-// https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/lib/builtins/fp_mul_impl.inc
-
-const std = @import("std");
-const math = std.math;
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
-const is_test = builtin.is_test;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    @export(__mulsf3, .{ .name = "__mulsf3", .linkage = linkage });
-    @export(__muldf3, .{ .name = "__muldf3", .linkage = linkage });
-    @export(__mulxf3, .{ .name = "__mulxf3", .linkage = linkage });
-    @export(__multf3, .{ .name = "__multf3", .linkage = linkage });
-
-    if (!is_test) {
-        if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_fmul, .{ .name = "__aeabi_fmul", .linkage = linkage });
-            @export(__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = linkage });
-        }
-
-        if (arch.isPPC() or arch.isPPC64()) {
-            @export(__mulkf3, .{ .name = "__mulkf3", .linkage = linkage });
-        }
-    }
-}
-
-pub fn __mulkf3(a: f128, b: f128) callconv(.C) f128 {
-    return @call(.{ .modifier = .always_inline }, __multf3, .{ a, b });
-}
-pub fn __multf3(a: f128, b: f128) callconv(.C) f128 {
-    return mulXf3(f128, a, b);
-}
-pub fn __mulxf3(a: f80, b: f80) callconv(.C) f80 {
-    return mulXf3(f80, a, b);
-}
-pub fn __muldf3(a: f64, b: f64) callconv(.C) f64 {
-    return mulXf3(f64, a, b);
-}
-pub fn __mulsf3(a: f32, b: f32) callconv(.C) f32 {
-    return mulXf3(f32, a, b);
-}
-
-pub fn __aeabi_fmul(a: f32, b: f32) callconv(.C) f32 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __mulsf3, .{ a, b });
-}
-
-pub fn __aeabi_dmul(a: f64, b: f64) callconv(.C) f64 {
-    @setRuntimeSafety(false);
-    return @call(.{ .modifier = .always_inline }, __muldf3, .{ a, b });
-}
-
-pub fn mulXf3(comptime T: type, a: T, b: T) T {
-    @setRuntimeSafety(builtin.is_test);
-    const typeWidth = @typeInfo(T).Float.bits;
-    const significandBits = math.floatMantissaBits(T);
-    const fractionalBits = math.floatFractionalBits(T);
-    const exponentBits = math.floatExponentBits(T);
-
-    const Z = std.meta.Int(.unsigned, typeWidth);
-
-    // ZSignificand is large enough to contain the significand, including an explicit integer bit
-    const ZSignificand = PowerOfTwoSignificandZ(T);
-    const ZSignificandBits = @typeInfo(ZSignificand).Int.bits;
-
-    const roundBit = (1 << (ZSignificandBits - 1));
-    const signBit = (@as(Z, 1) << (significandBits + exponentBits));
-    const maxExponent = ((1 << exponentBits) - 1);
-    const exponentBias = (maxExponent >> 1);
-
-    const integerBit = (@as(ZSignificand, 1) << fractionalBits);
-    const quietBit = integerBit >> 1;
-    const significandMask = (@as(Z, 1) << significandBits) - 1;
-
-    const absMask = signBit - 1;
-    const qnanRep = @bitCast(Z, math.nan(T)) | quietBit;
-    const infRep = @bitCast(Z, math.inf(T));
-    const minNormalRep = @bitCast(Z, math.floatMin(T));
-
-    const aExponent = @truncate(u32, (@bitCast(Z, a) >> significandBits) & maxExponent);
-    const bExponent = @truncate(u32, (@bitCast(Z, b) >> significandBits) & maxExponent);
-    const productSign: Z = (@bitCast(Z, a) ^ @bitCast(Z, b)) & signBit;
-
-    var aSignificand: ZSignificand = @intCast(ZSignificand, @bitCast(Z, a) & significandMask);
-    var bSignificand: ZSignificand = @intCast(ZSignificand, @bitCast(Z, b) & significandMask);
-    var scale: i32 = 0;
-
-    // Detect if a or b is zero, denormal, infinity, or NaN.
-    if (aExponent -% 1 >= maxExponent - 1 or bExponent -% 1 >= maxExponent - 1) {
-        const aAbs: Z = @bitCast(Z, a) & absMask;
-        const bAbs: Z = @bitCast(Z, b) & absMask;
-
-        // NaN * anything = qNaN
-        if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
-        // anything * NaN = qNaN
-        if (bAbs > infRep) return @bitCast(T, @bitCast(Z, b) | quietBit);
-
-        if (aAbs == infRep) {
-            // infinity * non-zero = +/- infinity
-            if (bAbs != 0) {
-                return @bitCast(T, aAbs | productSign);
-            } else {
-                // infinity * zero = NaN
-                return @bitCast(T, qnanRep);
-            }
-        }
-
-        if (bAbs == infRep) {
-            //? non-zero * infinity = +/- infinity
-            if (aAbs != 0) {
-                return @bitCast(T, bAbs | productSign);
-            } else {
-                // zero * infinity = NaN
-                return @bitCast(T, qnanRep);
-            }
-        }
-
-        // zero * anything = +/- zero
-        if (aAbs == 0) return @bitCast(T, productSign);
-        // anything * zero = +/- zero
-        if (bAbs == 0) return @bitCast(T, productSign);
-
-        // one or both of a or b is denormal, the other (if applicable) is a
-        // normal number.  Renormalize one or both of a and b, and set scale to
-        // include the necessary exponent adjustment.
-        if (aAbs < minNormalRep) scale += normalize(T, &aSignificand);
-        if (bAbs < minNormalRep) scale += normalize(T, &bSignificand);
-    }
-
-    // Or in the implicit significand bit.  (If we fell through from the
-    // denormal path it was already set by normalize( ), but setting it twice
-    // won't hurt anything.)
-    aSignificand |= integerBit;
-    bSignificand |= integerBit;
-
-    // Get the significand of a*b.  Before multiplying the significands, shift
-    // one of them left to left-align it in the field.  Thus, the product will
-    // have (exponentBits + 2) integral digits, all but two of which must be
-    // zero.  Normalizing this result is just a conditional left-shift by one
-    // and bumping the exponent accordingly.
-    var productHi: ZSignificand = undefined;
-    var productLo: ZSignificand = undefined;
-    const left_align_shift = ZSignificandBits - fractionalBits - 1;
-    wideMultiply(ZSignificand, aSignificand, bSignificand << left_align_shift, &productHi, &productLo);
-
-    var productExponent: i32 = @intCast(i32, aExponent + bExponent) - exponentBias + scale;
-
-    // Normalize the significand, adjust exponent if needed.
-    if ((productHi & integerBit) != 0) {
-        productExponent +%= 1;
-    } else {
-        productHi = (productHi << 1) | (productLo >> (ZSignificandBits - 1));
-        productLo = productLo << 1;
-    }
-
-    // If we have overflowed the type, return +/- infinity.
-    if (productExponent >= maxExponent) return @bitCast(T, infRep | productSign);
-
-    var result: Z = undefined;
-    if (productExponent <= 0) {
-        // Result is denormal before rounding
-        //
-        // If the result is so small that it just underflows to zero, return
-        // a zero of the appropriate sign.  Mathematically there is no need to
-        // handle this case separately, but we make it a special case to
-        // simplify the shift logic.
-        const shift: u32 = @truncate(u32, @as(Z, 1) -% @bitCast(u32, productExponent));
-        if (shift >= ZSignificandBits) return @bitCast(T, productSign);
-
-        // Otherwise, shift the significand of the result so that the round
-        // bit is the high bit of productLo.
-        const sticky = wideShrWithTruncation(ZSignificand, &productHi, &productLo, shift);
-        productLo |= @boolToInt(sticky);
-        result = productHi;
-
-        // We include the integer bit so that rounding will carry to the exponent,
-        // but it will be removed later if the result is still denormal
-        if (significandBits != fractionalBits) result |= integerBit;
-    } else {
-        // Result is normal before rounding; insert the exponent.
-        result = productHi & significandMask;
-        result |= @intCast(Z, productExponent) << significandBits;
-    }
-
-    // Final rounding.  The final result may overflow to infinity, or underflow
-    // to zero, but those are the correct results in those cases.  We use the
-    // default IEEE-754 round-to-nearest, ties-to-even rounding mode.
-    if (productLo > roundBit) result +%= 1;
-    if (productLo == roundBit) result +%= result & 1;
-
-    // Restore any explicit integer bit, if it was rounded off
-    if (significandBits != fractionalBits) {
-        if ((result >> significandBits) != 0) {
-            result |= integerBit;
-        } else {
-            result &= ~integerBit;
-        }
-    }
-
-    // Insert the sign of the result:
-    result |= productSign;
-
-    return @bitCast(T, result);
-}
-
-fn wideMultiply(comptime Z: type, a: Z, b: Z, hi: *Z, lo: *Z) void {
-    @setRuntimeSafety(builtin.is_test);
-    switch (Z) {
-        u16 => {
-            // 16x16 --> 32 bit multiply
-            const product = @as(u32, a) * @as(u32, b);
-            hi.* = @intCast(u16, product >> 16);
-            lo.* = @truncate(u16, product);
-        },
-        u32 => {
-            // 32x32 --> 64 bit multiply
-            const product = @as(u64, a) * @as(u64, b);
-            hi.* = @intCast(u32, product >> 32);
-            lo.* = @truncate(u32, product);
-        },
-        u64 => {
-            const S = struct {
-                fn loWord(x: u64) u64 {
-                    return @truncate(u32, x);
-                }
-                fn hiWord(x: u64) u64 {
-                    return @intCast(u32, x >> 32);
-                }
-            };
-            // 64x64 -> 128 wide multiply for platforms that don't have such an operation;
-            // many 64-bit platforms have this operation, but they tend to have hardware
-            // floating-point, so we don't bother with a special case for them here.
-            // Each of the component 32x32 -> 64 products
-            const plolo: u64 = S.loWord(a) * S.loWord(b);
-            const plohi: u64 = S.loWord(a) * S.hiWord(b);
-            const philo: u64 = S.hiWord(a) * S.loWord(b);
-            const phihi: u64 = S.hiWord(a) * S.hiWord(b);
-            // Sum terms that contribute to lo in a way that allows us to get the carry
-            const r0: u64 = S.loWord(plolo);
-            const r1: u64 = S.hiWord(plolo) +% S.loWord(plohi) +% S.loWord(philo);
-            lo.* = r0 +% (r1 << 32);
-            // Sum terms contributing to hi with the carry from lo
-            hi.* = S.hiWord(plohi) +% S.hiWord(philo) +% S.hiWord(r1) +% phihi;
-        },
-        u128 => {
-            const Word_LoMask = @as(u64, 0x00000000ffffffff);
-            const Word_HiMask = @as(u64, 0xffffffff00000000);
-            const Word_FullMask = @as(u64, 0xffffffffffffffff);
-            const S = struct {
-                fn Word_1(x: u128) u64 {
-                    return @truncate(u32, x >> 96);
-                }
-                fn Word_2(x: u128) u64 {
-                    return @truncate(u32, x >> 64);
-                }
-                fn Word_3(x: u128) u64 {
-                    return @truncate(u32, x >> 32);
-                }
-                fn Word_4(x: u128) u64 {
-                    return @truncate(u32, x);
-                }
-            };
-            // 128x128 -> 256 wide multiply for platforms that don't have such an operation;
-            // many 64-bit platforms have this operation, but they tend to have hardware
-            // floating-point, so we don't bother with a special case for them here.
-
-            const product11: u64 = S.Word_1(a) * S.Word_1(b);
-            const product12: u64 = S.Word_1(a) * S.Word_2(b);
-            const product13: u64 = S.Word_1(a) * S.Word_3(b);
-            const product14: u64 = S.Word_1(a) * S.Word_4(b);
-            const product21: u64 = S.Word_2(a) * S.Word_1(b);
-            const product22: u64 = S.Word_2(a) * S.Word_2(b);
-            const product23: u64 = S.Word_2(a) * S.Word_3(b);
-            const product24: u64 = S.Word_2(a) * S.Word_4(b);
-            const product31: u64 = S.Word_3(a) * S.Word_1(b);
-            const product32: u64 = S.Word_3(a) * S.Word_2(b);
-            const product33: u64 = S.Word_3(a) * S.Word_3(b);
-            const product34: u64 = S.Word_3(a) * S.Word_4(b);
-            const product41: u64 = S.Word_4(a) * S.Word_1(b);
-            const product42: u64 = S.Word_4(a) * S.Word_2(b);
-            const product43: u64 = S.Word_4(a) * S.Word_3(b);
-            const product44: u64 = S.Word_4(a) * S.Word_4(b);
-
-            const sum0: u128 = @as(u128, product44);
-            const sum1: u128 = @as(u128, product34) +%
-                @as(u128, product43);
-            const sum2: u128 = @as(u128, product24) +%
-                @as(u128, product33) +%
-                @as(u128, product42);
-            const sum3: u128 = @as(u128, product14) +%
-                @as(u128, product23) +%
-                @as(u128, product32) +%
-                @as(u128, product41);
-            const sum4: u128 = @as(u128, product13) +%
-                @as(u128, product22) +%
-                @as(u128, product31);
-            const sum5: u128 = @as(u128, product12) +%
-                @as(u128, product21);
-            const sum6: u128 = @as(u128, product11);
-
-            const r0: u128 = (sum0 & Word_FullMask) +%
-                ((sum1 & Word_LoMask) << 32);
-            const r1: u128 = (sum0 >> 64) +%
-                ((sum1 >> 32) & Word_FullMask) +%
-                (sum2 & Word_FullMask) +%
-                ((sum3 << 32) & Word_HiMask);
-
-            lo.* = r0 +% (r1 << 64);
-            hi.* = (r1 >> 64) +%
-                (sum1 >> 96) +%
-                (sum2 >> 64) +%
-                (sum3 >> 32) +%
-                sum4 +%
-                (sum5 << 32) +%
-                (sum6 << 64);
-        },
-        else => @compileError("unsupported"),
-    }
-}
-
-/// Returns a power-of-two integer type that is large enough to contain
-/// the significand of T, including an explicit integer bit
-fn PowerOfTwoSignificandZ(comptime T: type) type {
-    const bits = math.ceilPowerOfTwoAssert(u16, math.floatFractionalBits(T) + 1);
-    return std.meta.Int(.unsigned, bits);
-}
-
-fn normalize(comptime T: type, significand: *PowerOfTwoSignificandZ(T)) i32 {
-    @setRuntimeSafety(builtin.is_test);
-    const Z = PowerOfTwoSignificandZ(T);
-    const integerBit = @as(Z, 1) << math.floatFractionalBits(T);
-
-    const shift = @clz(Z, significand.*) - @clz(Z, integerBit);
-    significand.* <<= @intCast(math.Log2Int(Z), shift);
-    return @as(i32, 1) - shift;
-}
-
-// Returns `true` if the right shift is inexact (i.e. any bit shifted out is non-zero)
-//
-// This is analogous to an shr version of `@shlWithOverflow`
-fn wideShrWithTruncation(comptime Z: type, hi: *Z, lo: *Z, count: u32) bool {
-    @setRuntimeSafety(builtin.is_test);
-    const typeWidth = @typeInfo(Z).Int.bits;
-    const S = math.Log2Int(Z);
-    var inexact = false;
-    if (count < typeWidth) {
-        inexact = (lo.* << @intCast(S, typeWidth -% count)) != 0;
-        lo.* = (hi.* << @intCast(S, typeWidth -% count)) | (lo.* >> @intCast(S, count));
-        hi.* = hi.* >> @intCast(S, count);
-    } else if (count < 2 * typeWidth) {
-        inexact = (hi.* << @intCast(S, 2 * typeWidth -% count) | lo.*) != 0;
-        lo.* = hi.* >> @intCast(S, count -% typeWidth);
-        hi.* = 0;
-    } else {
-        inexact = (hi.* | lo.*) != 0;
-        lo.* = 0;
-        hi.* = 0;
-    }
-    return inexact;
-}
-
-test {
-    _ = @import("mulXf3_test.zig");
-}
diff --git a/lib/compiler_rt/mulXf3_test.zig b/lib/compiler_rt/mulXf3_test.zig
deleted file mode 100644
index 6b4f8ca95363f2afcc72a7a1f1207a65b75f56d7..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/mulXf3_test.zig
+++ /dev/null
@@ -1,171 +0,0 @@
-// Ported from:
-//
-// https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/test/builtins/Unit/multf3_test.c
-
-const std = @import("std");
-const math = std.math;
-const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
-const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
-
-const __multf3 = @import("mulXf3.zig").__multf3;
-const __mulxf3 = @import("mulXf3.zig").__mulxf3;
-const __muldf3 = @import("mulXf3.zig").__muldf3;
-const __mulsf3 = @import("mulXf3.zig").__mulsf3;
-
-// return true if equal
-// use two 64-bit integers intead of one 128-bit integer
-// because 128-bit integer constant can't be assigned directly
-fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
-    const rep = @bitCast(u128, result);
-    const hi = @intCast(u64, rep >> 64);
-    const lo = @truncate(u64, rep);
-
-    if (hi == expectedHi and lo == expectedLo) {
-        return true;
-    }
-    // test other possible NaN representation(signal NaN)
-    if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
-        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
-            ((hi & 0xffffffffffff) > 0 or lo > 0))
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
-    const x = __multf3(a, b);
-
-    if (compareResultLD(x, expected_hi, expected_lo))
-        return;
-
-    @panic("__multf3 test failure");
-}
-
-fn makeNaN128(rand: u64) f128 {
-    const int_result = @as(u128, 0x7fff000000000000 | (rand & 0xffffffffffff)) << 64;
-    const float_result = @bitCast(f128, int_result);
-    return float_result;
-}
-test "multf3" {
-    // qNaN * any = qNaN
-    try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
-
-    // NaN * any = NaN
-    const a = makeNaN128(0x800030000000);
-    try test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
-    // inf * any = inf
-    try test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
-
-    // any * any
-    try test__multf3(
-        @bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),
-        @bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),
-        0x400423e7f9e3c9fc,
-        0xd906c2c2a85777c4,
-    );
-
-    try test__multf3(
-        @bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),
-        @bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),
-        0x3fc52a163c6223fc,
-        0xc94c4bf0430768b4,
-    );
-
-    try test__multf3(
-        0x1.234425696abcad34a35eeffefdcbap+456,
-        0x451.ed98d76e5d46e5f24323dff21ffp+600,
-        0x44293a91de5e0e94,
-        0xe8ed17cc2cdf64ac,
-    );
-
-    try test__multf3(
-        @bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),
-        @bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),
-        0x3d4f37c1a3137cae,
-        0xfc6807048bc2836a,
-    );
-
-    try test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);
-
-    // Denormal operands.
-    try test__multf3(
-        0x0.0000000000000000000000000001p-16382,
-        0x1p16383,
-        0x3f90000000000000,
-        0x0,
-    );
-    try test__multf3(
-        0x1p16383,
-        0x0.0000000000000000000000000001p-16382,
-        0x3f90000000000000,
-        0x0,
-    );
-
-    try test__multf3(0x1.0000_0000_0000_0000_0000_0000_0001p+0, 0x1.8p+5, 0x4004_8000_0000_0000, 0x0000_0000_0000_0002);
-    try test__multf3(0x1.0000_0000_0000_0000_0000_0000_0002p+0, 0x1.8p+5, 0x4004_8000_0000_0000, 0x0000_0000_0000_0003);
-    try test__multf3(2.0, math.floatTrueMin(f128), 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
-}
-
-const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) | (1 << (math.floatFractionalBits(f80) - 1)));
-
-fn test__mulxf3(a: f80, b: f80, expected: u80) !void {
-    const x = __mulxf3(a, b);
-    const rep = @bitCast(u80, x);
-
-    if (rep == expected)
-        return;
-
-    if (math.isNan(@bitCast(f80, expected)) and math.isNan(x))
-        return; // We don't currently test NaN payload propagation
-
-    return error.TestFailed;
-}
-
-test "mulxf3" {
-    // NaN * any = NaN
-    try test__mulxf3(qnan80, 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
-    try test__mulxf3(@bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
-
-    // any * NaN = NaN
-    try test__mulxf3(0x1.23456789abcdefp+5, qnan80, @bitCast(u80, qnan80));
-    try test__mulxf3(0x1.23456789abcdefp+5, @bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), @bitCast(u80, qnan80));
-
-    // NaN * inf = NaN
-    try test__mulxf3(qnan80, math.inf(f80), @bitCast(u80, qnan80));
-
-    // inf * NaN = NaN
-    try test__mulxf3(math.inf(f80), qnan80, @bitCast(u80, qnan80));
-
-    // inf * inf = inf
-    try test__mulxf3(math.inf(f80), math.inf(f80), @bitCast(u80, math.inf(f80)));
-
-    // inf * -inf = -inf
-    try test__mulxf3(math.inf(f80), -math.inf(f80), @bitCast(u80, -math.inf(f80)));
-
-    // -inf + inf = -inf
-    try test__mulxf3(-math.inf(f80), math.inf(f80), @bitCast(u80, -math.inf(f80)));
-
-    // inf * any = inf
-    try test__mulxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @bitCast(u80, math.inf(f80)));
-
-    // any * inf = inf
-    try test__mulxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @bitCast(u80, math.inf(f80)));
-
-    // any * any
-    try test__mulxf3(0x1.0p+0, 0x1.dcba987654321p+5, 0x4004_ee5d_4c3b_2a19_0800);
-    try test__mulxf3(0x1.0000_0000_0000_0004p+0, 0x1.8p+5, 0x4004_C000_0000_0000_0003); // exact
-
-    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.0p+5, 0x4004_8000_0000_0000_0001); // exact
-    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.7ffep+5, 0x4004_BFFF_0000_0000_0001); // round down
-    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.8p+5, 0x4004_C000_0000_0000_0002); // round up to even
-    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.8002p+5, 0x4004_C001_0000_0000_0002); // round up
-    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.0p+6, 0x4005_8000_0000_0000_0001); // exact
-
-    try test__mulxf3(0x1.0000_0001p+0, 0x1.0000_0001p+0, 0x3FFF_8000_0001_0000_0000); // round down to even
-    try test__mulxf3(0x1.0000_0001p+0, 0x1.0000_0001_0002p+0, 0x3FFF_8000_0001_0001_0001); // round up
-    try test__mulxf3(0x0.8000_0000_0000_0000p-16382, 2.0, 0x0001_8000_0000_0000_0000); // denormal -> normal
-    try test__mulxf3(0x0.7fff_ffff_ffff_fffep-16382, 0x2.0000_0000_0000_0008p0, 0x0001_8000_0000_0000_0000); // denormal -> normal
-    try test__mulxf3(0x0.7fff_ffff_ffff_fffep-16382, 0x1.0000_0000_0000_0000p0, 0x0000_3FFF_FFFF_FFFF_FFFF); // denormal -> denormal
-}
diff --git a/lib/compiler_rt/muldf3.zig b/lib/compiler_rt/muldf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c9142a9ed39aa2d0b065b2b6723fb7ca1129e84b
--- /dev/null
+++ b/lib/compiler_rt/muldf3.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const mulf3 = @import("./mulf3.zig").mulf3;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_dmul, .{ .name = "__aeabi_dmul", .linkage = common.linkage });
+    } else {
+        @export(__muldf3, .{ .name = "__muldf3", .linkage = common.linkage });
+    }
+}
+
+fn __muldf3(a: f64, b: f64) callconv(.C) f64 {
+    return mulf3(f64, a, b);
+}
+
+fn __aeabi_dmul(a: f64, b: f64) callconv(.C) f64 {
+    return mulf3(f64, a, b);
+}
diff --git a/lib/compiler_rt/mulf3.zig b/lib/compiler_rt/mulf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f6949ee3ce52063c0ee5a5310f7bc81b6c515ed5
--- /dev/null
+++ b/lib/compiler_rt/mulf3.zig
@@ -0,0 +1,203 @@
+const std = @import("std");
+const math = std.math;
+const builtin = @import("builtin");
+const common = @import("./common.zig");
+
+/// Ported from:
+/// https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/lib/builtins/fp_mul_impl.inc
+pub inline fn mulf3(comptime T: type, a: T, b: T) T {
+    @setRuntimeSafety(builtin.is_test);
+    const typeWidth = @typeInfo(T).Float.bits;
+    const significandBits = math.floatMantissaBits(T);
+    const fractionalBits = math.floatFractionalBits(T);
+    const exponentBits = math.floatExponentBits(T);
+
+    const Z = std.meta.Int(.unsigned, typeWidth);
+
+    // ZSignificand is large enough to contain the significand, including an explicit integer bit
+    const ZSignificand = PowerOfTwoSignificandZ(T);
+    const ZSignificandBits = @typeInfo(ZSignificand).Int.bits;
+
+    const roundBit = (1 << (ZSignificandBits - 1));
+    const signBit = (@as(Z, 1) << (significandBits + exponentBits));
+    const maxExponent = ((1 << exponentBits) - 1);
+    const exponentBias = (maxExponent >> 1);
+
+    const integerBit = (@as(ZSignificand, 1) << fractionalBits);
+    const quietBit = integerBit >> 1;
+    const significandMask = (@as(Z, 1) << significandBits) - 1;
+
+    const absMask = signBit - 1;
+    const qnanRep = @bitCast(Z, math.nan(T)) | quietBit;
+    const infRep = @bitCast(Z, math.inf(T));
+    const minNormalRep = @bitCast(Z, math.floatMin(T));
+
+    const aExponent = @truncate(u32, (@bitCast(Z, a) >> significandBits) & maxExponent);
+    const bExponent = @truncate(u32, (@bitCast(Z, b) >> significandBits) & maxExponent);
+    const productSign: Z = (@bitCast(Z, a) ^ @bitCast(Z, b)) & signBit;
+
+    var aSignificand: ZSignificand = @intCast(ZSignificand, @bitCast(Z, a) & significandMask);
+    var bSignificand: ZSignificand = @intCast(ZSignificand, @bitCast(Z, b) & significandMask);
+    var scale: i32 = 0;
+
+    // Detect if a or b is zero, denormal, infinity, or NaN.
+    if (aExponent -% 1 >= maxExponent - 1 or bExponent -% 1 >= maxExponent - 1) {
+        const aAbs: Z = @bitCast(Z, a) & absMask;
+        const bAbs: Z = @bitCast(Z, b) & absMask;
+
+        // NaN * anything = qNaN
+        if (aAbs > infRep) return @bitCast(T, @bitCast(Z, a) | quietBit);
+        // anything * NaN = qNaN
+        if (bAbs > infRep) return @bitCast(T, @bitCast(Z, b) | quietBit);
+
+        if (aAbs == infRep) {
+            // infinity * non-zero = +/- infinity
+            if (bAbs != 0) {
+                return @bitCast(T, aAbs | productSign);
+            } else {
+                // infinity * zero = NaN
+                return @bitCast(T, qnanRep);
+            }
+        }
+
+        if (bAbs == infRep) {
+            //? non-zero * infinity = +/- infinity
+            if (aAbs != 0) {
+                return @bitCast(T, bAbs | productSign);
+            } else {
+                // zero * infinity = NaN
+                return @bitCast(T, qnanRep);
+            }
+        }
+
+        // zero * anything = +/- zero
+        if (aAbs == 0) return @bitCast(T, productSign);
+        // anything * zero = +/- zero
+        if (bAbs == 0) return @bitCast(T, productSign);
+
+        // one or both of a or b is denormal, the other (if applicable) is a
+        // normal number.  Renormalize one or both of a and b, and set scale to
+        // include the necessary exponent adjustment.
+        if (aAbs < minNormalRep) scale += normalize(T, &aSignificand);
+        if (bAbs < minNormalRep) scale += normalize(T, &bSignificand);
+    }
+
+    // Or in the implicit significand bit.  (If we fell through from the
+    // denormal path it was already set by normalize( ), but setting it twice
+    // won't hurt anything.)
+    aSignificand |= integerBit;
+    bSignificand |= integerBit;
+
+    // Get the significand of a*b.  Before multiplying the significands, shift
+    // one of them left to left-align it in the field.  Thus, the product will
+    // have (exponentBits + 2) integral digits, all but two of which must be
+    // zero.  Normalizing this result is just a conditional left-shift by one
+    // and bumping the exponent accordingly.
+    var productHi: ZSignificand = undefined;
+    var productLo: ZSignificand = undefined;
+    const left_align_shift = ZSignificandBits - fractionalBits - 1;
+    common.wideMultiply(ZSignificand, aSignificand, bSignificand << left_align_shift, &productHi, &productLo);
+
+    var productExponent: i32 = @intCast(i32, aExponent + bExponent) - exponentBias + scale;
+
+    // Normalize the significand, adjust exponent if needed.
+    if ((productHi & integerBit) != 0) {
+        productExponent +%= 1;
+    } else {
+        productHi = (productHi << 1) | (productLo >> (ZSignificandBits - 1));
+        productLo = productLo << 1;
+    }
+
+    // If we have overflowed the type, return +/- infinity.
+    if (productExponent >= maxExponent) return @bitCast(T, infRep | productSign);
+
+    var result: Z = undefined;
+    if (productExponent <= 0) {
+        // Result is denormal before rounding
+        //
+        // If the result is so small that it just underflows to zero, return
+        // a zero of the appropriate sign.  Mathematically there is no need to
+        // handle this case separately, but we make it a special case to
+        // simplify the shift logic.
+        const shift: u32 = @truncate(u32, @as(Z, 1) -% @bitCast(u32, productExponent));
+        if (shift >= ZSignificandBits) return @bitCast(T, productSign);
+
+        // Otherwise, shift the significand of the result so that the round
+        // bit is the high bit of productLo.
+        const sticky = wideShrWithTruncation(ZSignificand, &productHi, &productLo, shift);
+        productLo |= @boolToInt(sticky);
+        result = productHi;
+
+        // We include the integer bit so that rounding will carry to the exponent,
+        // but it will be removed later if the result is still denormal
+        if (significandBits != fractionalBits) result |= integerBit;
+    } else {
+        // Result is normal before rounding; insert the exponent.
+        result = productHi & significandMask;
+        result |= @intCast(Z, productExponent) << significandBits;
+    }
+
+    // Final rounding.  The final result may overflow to infinity, or underflow
+    // to zero, but those are the correct results in those cases.  We use the
+    // default IEEE-754 round-to-nearest, ties-to-even rounding mode.
+    if (productLo > roundBit) result +%= 1;
+    if (productLo == roundBit) result +%= result & 1;
+
+    // Restore any explicit integer bit, if it was rounded off
+    if (significandBits != fractionalBits) {
+        if ((result >> significandBits) != 0) {
+            result |= integerBit;
+        } else {
+            result &= ~integerBit;
+        }
+    }
+
+    // Insert the sign of the result:
+    result |= productSign;
+
+    return @bitCast(T, result);
+}
+
+/// Returns `true` if the right shift is inexact (i.e. any bit shifted out is non-zero)
+///
+/// This is analogous to an shr version of `@shlWithOverflow`
+fn wideShrWithTruncation(comptime Z: type, hi: *Z, lo: *Z, count: u32) bool {
+    @setRuntimeSafety(builtin.is_test);
+    const typeWidth = @typeInfo(Z).Int.bits;
+    const S = math.Log2Int(Z);
+    var inexact = false;
+    if (count < typeWidth) {
+        inexact = (lo.* << @intCast(S, typeWidth -% count)) != 0;
+        lo.* = (hi.* << @intCast(S, typeWidth -% count)) | (lo.* >> @intCast(S, count));
+        hi.* = hi.* >> @intCast(S, count);
+    } else if (count < 2 * typeWidth) {
+        inexact = (hi.* << @intCast(S, 2 * typeWidth -% count) | lo.*) != 0;
+        lo.* = hi.* >> @intCast(S, count -% typeWidth);
+        hi.* = 0;
+    } else {
+        inexact = (hi.* | lo.*) != 0;
+        lo.* = 0;
+        hi.* = 0;
+    }
+    return inexact;
+}
+
+fn normalize(comptime T: type, significand: *PowerOfTwoSignificandZ(T)) i32 {
+    const Z = PowerOfTwoSignificandZ(T);
+    const integerBit = @as(Z, 1) << math.floatFractionalBits(T);
+
+    const shift = @clz(Z, significand.*) - @clz(Z, integerBit);
+    significand.* <<= @intCast(math.Log2Int(Z), shift);
+    return @as(i32, 1) - shift;
+}
+
+/// Returns a power-of-two integer type that is large enough to contain
+/// the significand of T, including an explicit integer bit
+fn PowerOfTwoSignificandZ(comptime T: type) type {
+    const bits = math.ceilPowerOfTwoAssert(u16, math.floatFractionalBits(T) + 1);
+    return std.meta.Int(.unsigned, bits);
+}
+
+test {
+    _ = @import("mulf3_test.zig");
+}
diff --git a/lib/compiler_rt/mulf3_test.zig b/lib/compiler_rt/mulf3_test.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0c7d84c5e077bf479e8ac7a7bcd9d29cd8df9eea
--- /dev/null
+++ b/lib/compiler_rt/mulf3_test.zig
@@ -0,0 +1,171 @@
+// Ported from:
+//
+// https://github.com/llvm/llvm-project/blob/2ffb1b0413efa9a24eb3c49e710e36f92e2cb50b/compiler-rt/test/builtins/Unit/multf3_test.c
+
+const std = @import("std");
+const math = std.math;
+const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
+const inf128 = @bitCast(f128, @as(u128, 0x7fff000000000000) << 64);
+
+const __multf3 = @import("mulf3.zig").__multf3;
+const __mulxf3 = @import("mulf3.zig").__mulxf3;
+const __muldf3 = @import("mulf3.zig").__muldf3;
+const __mulsf3 = @import("mulf3.zig").__mulsf3;
+
+// return true if equal
+// use two 64-bit integers intead of one 128-bit integer
+// because 128-bit integer constant can't be assigned directly
+fn compareResultLD(result: f128, expectedHi: u64, expectedLo: u64) bool {
+    const rep = @bitCast(u128, result);
+    const hi = @intCast(u64, rep >> 64);
+    const lo = @truncate(u64, rep);
+
+    if (hi == expectedHi and lo == expectedLo) {
+        return true;
+    }
+    // test other possible NaN representation(signal NaN)
+    if (expectedHi == 0x7fff800000000000 and expectedLo == 0x0) {
+        if ((hi & 0x7fff000000000000) == 0x7fff000000000000 and
+            ((hi & 0xffffffffffff) > 0 or lo > 0))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+fn test__multf3(a: f128, b: f128, expected_hi: u64, expected_lo: u64) !void {
+    const x = __multf3(a, b);
+
+    if (compareResultLD(x, expected_hi, expected_lo))
+        return;
+
+    @panic("__multf3 test failure");
+}
+
+fn makeNaN128(rand: u64) f128 {
+    const int_result = @as(u128, 0x7fff000000000000 | (rand & 0xffffffffffff)) << 64;
+    const float_result = @bitCast(f128, int_result);
+    return float_result;
+}
+test "multf3" {
+    // qNaN * any = qNaN
+    try test__multf3(qnan128, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+
+    // NaN * any = NaN
+    const a = makeNaN128(0x800030000000);
+    try test__multf3(a, 0x1.23456789abcdefp+5, 0x7fff800000000000, 0x0);
+    // inf * any = inf
+    try test__multf3(inf128, 0x1.23456789abcdefp+5, 0x7fff000000000000, 0x0);
+
+    // any * any
+    try test__multf3(
+        @bitCast(f128, @as(u128, 0x40042eab345678439abcdefea5678234)),
+        @bitCast(f128, @as(u128, 0x3ffeedcb34a235253948765432134675)),
+        0x400423e7f9e3c9fc,
+        0xd906c2c2a85777c4,
+    );
+
+    try test__multf3(
+        @bitCast(f128, @as(u128, 0x3fcd353e45674d89abacc3a2ebf3ff50)),
+        @bitCast(f128, @as(u128, 0x3ff6ed8764648369535adf4be3214568)),
+        0x3fc52a163c6223fc,
+        0xc94c4bf0430768b4,
+    );
+
+    try test__multf3(
+        0x1.234425696abcad34a35eeffefdcbap+456,
+        0x451.ed98d76e5d46e5f24323dff21ffp+600,
+        0x44293a91de5e0e94,
+        0xe8ed17cc2cdf64ac,
+    );
+
+    try test__multf3(
+        @bitCast(f128, @as(u128, 0x3f154356473c82a9fabf2d22ace345df)),
+        @bitCast(f128, @as(u128, 0x3e38eda98765476743ab21da23d45679)),
+        0x3d4f37c1a3137cae,
+        0xfc6807048bc2836a,
+    );
+
+    try test__multf3(0x1.23456734245345p-10000, 0x1.edcba524498724p-6497, 0x0, 0x0);
+
+    // Denormal operands.
+    try test__multf3(
+        0x0.0000000000000000000000000001p-16382,
+        0x1p16383,
+        0x3f90000000000000,
+        0x0,
+    );
+    try test__multf3(
+        0x1p16383,
+        0x0.0000000000000000000000000001p-16382,
+        0x3f90000000000000,
+        0x0,
+    );
+
+    try test__multf3(0x1.0000_0000_0000_0000_0000_0000_0001p+0, 0x1.8p+5, 0x4004_8000_0000_0000, 0x0000_0000_0000_0002);
+    try test__multf3(0x1.0000_0000_0000_0000_0000_0000_0002p+0, 0x1.8p+5, 0x4004_8000_0000_0000, 0x0000_0000_0000_0003);
+    try test__multf3(2.0, math.floatTrueMin(f128), 0x0000_0000_0000_0000, 0x0000_0000_0000_0002);
+}
+
+const qnan80 = @bitCast(f80, @bitCast(u80, math.nan(f80)) | (1 << (math.floatFractionalBits(f80) - 1)));
+
+fn test__mulxf3(a: f80, b: f80, expected: u80) !void {
+    const x = __mulxf3(a, b);
+    const rep = @bitCast(u80, x);
+
+    if (rep == expected)
+        return;
+
+    if (math.isNan(@bitCast(f80, expected)) and math.isNan(x))
+        return; // We don't currently test NaN payload propagation
+
+    return error.TestFailed;
+}
+
+test "mulxf3" {
+    // NaN * any = NaN
+    try test__mulxf3(qnan80, 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
+    try test__mulxf3(@bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), 0x1.23456789abcdefp+5, @bitCast(u80, qnan80));
+
+    // any * NaN = NaN
+    try test__mulxf3(0x1.23456789abcdefp+5, qnan80, @bitCast(u80, qnan80));
+    try test__mulxf3(0x1.23456789abcdefp+5, @bitCast(f80, @as(u80, 0x7fff_8000_8000_3000_0000)), @bitCast(u80, qnan80));
+
+    // NaN * inf = NaN
+    try test__mulxf3(qnan80, math.inf(f80), @bitCast(u80, qnan80));
+
+    // inf * NaN = NaN
+    try test__mulxf3(math.inf(f80), qnan80, @bitCast(u80, qnan80));
+
+    // inf * inf = inf
+    try test__mulxf3(math.inf(f80), math.inf(f80), @bitCast(u80, math.inf(f80)));
+
+    // inf * -inf = -inf
+    try test__mulxf3(math.inf(f80), -math.inf(f80), @bitCast(u80, -math.inf(f80)));
+
+    // -inf + inf = -inf
+    try test__mulxf3(-math.inf(f80), math.inf(f80), @bitCast(u80, -math.inf(f80)));
+
+    // inf * any = inf
+    try test__mulxf3(math.inf(f80), 0x1.2335653452436234723489432abcdefp+5, @bitCast(u80, math.inf(f80)));
+
+    // any * inf = inf
+    try test__mulxf3(0x1.2335653452436234723489432abcdefp+5, math.inf(f80), @bitCast(u80, math.inf(f80)));
+
+    // any * any
+    try test__mulxf3(0x1.0p+0, 0x1.dcba987654321p+5, 0x4004_ee5d_4c3b_2a19_0800);
+    try test__mulxf3(0x1.0000_0000_0000_0004p+0, 0x1.8p+5, 0x4004_C000_0000_0000_0003); // exact
+
+    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.0p+5, 0x4004_8000_0000_0000_0001); // exact
+    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.7ffep+5, 0x4004_BFFF_0000_0000_0001); // round down
+    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.8p+5, 0x4004_C000_0000_0000_0002); // round up to even
+    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.8002p+5, 0x4004_C001_0000_0000_0002); // round up
+    try test__mulxf3(0x1.0000_0000_0000_0002p+0, 0x1.0p+6, 0x4005_8000_0000_0000_0001); // exact
+
+    try test__mulxf3(0x1.0000_0001p+0, 0x1.0000_0001p+0, 0x3FFF_8000_0001_0000_0000); // round down to even
+    try test__mulxf3(0x1.0000_0001p+0, 0x1.0000_0001_0002p+0, 0x3FFF_8000_0001_0001_0001); // round up
+    try test__mulxf3(0x0.8000_0000_0000_0000p-16382, 2.0, 0x0001_8000_0000_0000_0000); // denormal -> normal
+    try test__mulxf3(0x0.7fff_ffff_ffff_fffep-16382, 0x2.0000_0000_0000_0008p0, 0x0001_8000_0000_0000_0000); // denormal -> normal
+    try test__mulxf3(0x0.7fff_ffff_ffff_fffep-16382, 0x1.0000_0000_0000_0000p0, 0x0000_3FFF_FFFF_FFFF_FFFF); // denormal -> denormal
+}
diff --git a/lib/compiler_rt/mulsf3.zig b/lib/compiler_rt/mulsf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a425f9617e3d22efeeb85803889e3a66d24ff519
--- /dev/null
+++ b/lib/compiler_rt/mulsf3.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const mulf3 = @import("./mulf3.zig").mulf3;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_fmul, .{ .name = "__aeabi_fmul", .linkage = common.linkage });
+    } else {
+        @export(__mulsf3, .{ .name = "__mulsf3", .linkage = common.linkage });
+    }
+}
+
+fn __mulsf3(a: f32, b: f32) callconv(.C) f32 {
+    return mulf3(f32, a, b);
+}
+
+fn __aeabi_fmul(a: f32, b: f32) callconv(.C) f32 {
+    return mulf3(f32, a, b);
+}
diff --git a/lib/compiler_rt/multf3.zig b/lib/compiler_rt/multf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..f71867c9cab682fc0e5407d52bcd83d5416961a8
--- /dev/null
+++ b/lib/compiler_rt/multf3.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const mulf3 = @import("./mulf3.zig").mulf3;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__mulkf3, .{ .name = "__mulkf3", .linkage = common.linkage });
+    } else {
+        @export(__multf3, .{ .name = "__multf3", .linkage = common.linkage });
+    }
+}
+
+fn __multf3(a: f128, b: f128) callconv(.C) f128 {
+    return mulf3(f128, a, b);
+}
+
+fn __mulkf3(a: f128, b: f128) callconv(.C) f128 {
+    return mulf3(f128, a, b);
+}
diff --git a/lib/compiler_rt/mulxf3.zig b/lib/compiler_rt/mulxf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..353d27c2903feff7ce51c717a540245655b59541
--- /dev/null
+++ b/lib/compiler_rt/mulxf3.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const mulf3 = @import("./mulf3.zig").mulf3;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__mulxf3, .{ .name = "__mulxf3", .linkage = common.linkage });
+}
+
+pub fn __mulxf3(a: f80, b: f80) callconv(.C) f80 {
+    return mulf3(f80, a, b);
+}
diff --git a/lib/compiler_rt/sparc.zig b/lib/compiler_rt/sparc.zig
index f96ba4b41a677835cd097596d13b853ae70c499a..a39951a1c8bfe43d20c37234fbf8e178e51fc537 100644
--- a/lib/compiler_rt/sparc.zig
+++ b/lib/compiler_rt/sparc.zig
@@ -50,7 +50,7 @@ const FCMP = enum(i32) {
 // Basic arithmetic
 
 pub fn _Qp_add(c: *f128, a: *f128, b: *f128) callconv(.C) void {
-    c.* = @import("addXf3.zig").__addtf3(a.*, b.*);
+    c.* = @import("addf3.zig").__addtf3(a.*, b.*);
 }
 
 pub fn _Qp_div(c: *f128, a: *f128, b: *f128) callconv(.C) void {
@@ -58,11 +58,11 @@ pub fn _Qp_div(c: *f128, a: *f128, b: *f128) callconv(.C) void {
 }
 
 pub fn _Qp_mul(c: *f128, a: *f128, b: *f128) callconv(.C) void {
-    c.* = @import("mulXf3.zig").__multf3(a.*, b.*);
+    c.* = @import("mulf3.zig").__multf3(a.*, b.*);
 }
 
 pub fn _Qp_sub(c: *f128, a: *f128, b: *f128) callconv(.C) void {
-    c.* = @import("addXf3.zig").__subtf3(a.*, b.*);
+    c.* = @import("addf3.zig").__subtf3(a.*, b.*);
 }
 
 // Comparison
diff --git a/lib/compiler_rt/subdf3.zig b/lib/compiler_rt/subdf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..9d62ffe4807f2eec8e950a8fcff3dfe7db0bb06b
--- /dev/null
+++ b/lib/compiler_rt/subdf3.zig
@@ -0,0 +1,21 @@
+const common = @import("./common.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_dsub, .{ .name = "__aeabi_dsub", .linkage = common.linkage });
+    } else {
+        @export(__subdf3, .{ .name = "__subdf3", .linkage = common.linkage });
+    }
+}
+
+fn __subdf3(a: f64, b: f64) callconv(.C) f64 {
+    const neg_b = @bitCast(f64, @bitCast(u64, b) ^ (@as(u64, 1) << 63));
+    return a + neg_b;
+}
+
+fn __aeabi_dsub(a: f64, b: f64) callconv(.AAPCS) f64 {
+    const neg_b = @bitCast(f64, @bitCast(u64, b) ^ (@as(u64, 1) << 63));
+    return a + neg_b;
+}
diff --git a/lib/compiler_rt/subsf3.zig b/lib/compiler_rt/subsf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..472bccc899c1052e1a33c59612e6c8fdd3022956
--- /dev/null
+++ b/lib/compiler_rt/subsf3.zig
@@ -0,0 +1,21 @@
+const common = @import("./common.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_fsub, .{ .name = "__aeabi_fsub", .linkage = common.linkage });
+    } else {
+        @export(__subsf3, .{ .name = "__subsf3", .linkage = common.linkage });
+    }
+}
+
+fn __subsf3(a: f32, b: f32) callconv(.C) f32 {
+    const neg_b = @bitCast(f32, @bitCast(u32, b) ^ (@as(u32, 1) << 31));
+    return a + neg_b;
+}
+
+fn __aeabi_fsub(a: f32, b: f32) callconv(.AAPCS) f32 {
+    const neg_b = @bitCast(f32, @bitCast(u32, b) ^ (@as(u32, 1) << 31));
+    return a + neg_b;
+}
diff --git a/lib/compiler_rt/subtf3.zig b/lib/compiler_rt/subtf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a4e2f4dfaec3bb986a18bcbec05abdf2ab55286d
--- /dev/null
+++ b/lib/compiler_rt/subtf3.zig
@@ -0,0 +1,21 @@
+const common = @import("./common.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__subkf3, .{ .name = "__subkf3", .linkage = common.linkage });
+    } else {
+        @export(__subtf3, .{ .name = "__subtf3", .linkage = common.linkage });
+    }
+}
+
+fn __subtf3(a: f128, b: f128) callconv(.C) f128 {
+    const neg_b = @bitCast(f128, @bitCast(u128, b) ^ (@as(u128, 1) << 127));
+    return a + neg_b;
+}
+
+fn __subkf3(a: f128, b: f128) callconv(.C) f128 {
+    const neg_b = @bitCast(f128, @bitCast(u128, b) ^ (@as(u128, 1) << 127));
+    return a + neg_b;
+}
diff --git a/lib/compiler_rt/subxf3.zig b/lib/compiler_rt/subxf3.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a143f10ffe6779d1b64d92be3f05b9a832d8506a
--- /dev/null
+++ b/lib/compiler_rt/subxf3.zig
@@ -0,0 +1,15 @@
+const std = @import("std");
+const common = @import("./common.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__subxf3, .{ .name = "__subxf3", .linkage = common.linkage });
+}
+
+fn __subxf3(a: f80, b: f80) callconv(.C) f80 {
+    var b_rep = std.math.break_f80(b);
+    b_rep.exp ^= 0x8000;
+    const neg_b = std.math.make_f80(b_rep);
+    return a + neg_b;
+}
diff --git a/lib/compiler_rt/truncXfYf2.zig b/lib/compiler_rt/truncXfYf2.zig
deleted file mode 100644
index 77fabcbd759241b130a0a9ada132f3e63908e401..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/truncXfYf2.zig
+++ /dev/null
@@ -1,192 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
-const is_test = builtin.is_test;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    @export(__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = linkage });
-    @export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = linkage });
-    @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = linkage });
-    @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = linkage });
-
-    @export(__truncdfsf2, .{ .name = "__truncdfsf2", .linkage = linkage });
-    @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = linkage });
-
-    if (!is_test) {
-        @export(__gnu_f2h_ieee, .{ .name = "__gnu_f2h_ieee", .linkage = linkage });
-
-        if (arch.isARM() or arch.isThumb()) {
-            @export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = linkage });
-            @export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = linkage });
-            @export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = linkage });
-        }
-
-        if (arch.isPPC() or arch.isPPC64()) {
-            @export(__trunckfsf2, .{ .name = "__trunckfsf2", .linkage = linkage });
-            @export(__trunckfdf2, .{ .name = "__trunckfdf2", .linkage = linkage });
-        }
-    }
-}
-
-// AArch64 is the only ABI (at the moment) to support f16 arguments without the
-// need for extending them to wider fp types.
-// TODO remove this; do this type selection in the language rather than
-// here in compiler-rt.
-const F16T = if (arch.isAARCH64()) f16 else u16;
-
-pub fn __truncsfhf2(a: f32) callconv(.C) F16T {
-    return @bitCast(F16T, truncXfYf2(f16, f32, a));
-}
-
-pub fn __gnu_f2h_ieee(a: f32) callconv(.C) F16T {
-    return @call(.{ .modifier = .always_inline }, __truncsfhf2, .{a});
-}
-
-pub fn __truncdfhf2(a: f64) callconv(.C) F16T {
-    return @bitCast(F16T, truncXfYf2(f16, f64, a));
-}
-
-pub fn __trunctfhf2(a: f128) callconv(.C) F16T {
-    return @bitCast(F16T, truncXfYf2(f16, f128, a));
-}
-
-pub fn __trunctfsf2(a: f128) callconv(.C) f32 {
-    return truncXfYf2(f32, f128, a);
-}
-
-pub fn __trunckfsf2(a: f128) callconv(.C) f32 {
-    return truncXfYf2(f32, f128, a);
-}
-
-pub fn __trunctfdf2(a: f128) callconv(.C) f64 {
-    return truncXfYf2(f64, f128, a);
-}
-
-pub fn __trunckfdf2(a: f128) callconv(.C) f64 {
-    return truncXfYf2(f64, f128, a);
-}
-
-pub fn __truncdfsf2(a: f64) callconv(.C) f32 {
-    return truncXfYf2(f32, f64, a);
-}
-
-pub fn __aeabi_d2f(a: f64) callconv(.AAPCS) f32 {
-    @setRuntimeSafety(false);
-    return truncXfYf2(f32, f64, a);
-}
-
-pub fn __aeabi_d2h(a: f64) callconv(.AAPCS) u16 {
-    @setRuntimeSafety(false);
-    return @bitCast(F16T, truncXfYf2(f16, f64, a));
-}
-
-pub fn __aeabi_f2h(a: f32) callconv(.AAPCS) u16 {
-    @setRuntimeSafety(false);
-    return @bitCast(F16T, truncXfYf2(f16, f32, a));
-}
-
-inline fn truncXfYf2(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t {
-    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits);
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
-    const srcSigBits = std.math.floatMantissaBits(src_t);
-    const dstSigBits = std.math.floatMantissaBits(dst_t);
-    const SrcShift = std.math.Log2Int(src_rep_t);
-
-    // Various constants whose values follow from the type parameters.
-    // Any reasonable optimizer will fold and propagate all of these.
-    const srcBits = @typeInfo(src_t).Float.bits;
-    const srcExpBits = srcBits - srcSigBits - 1;
-    const srcInfExp = (1 << srcExpBits) - 1;
-    const srcExpBias = srcInfExp >> 1;
-
-    const srcMinNormal = 1 << srcSigBits;
-    const srcSignificandMask = srcMinNormal - 1;
-    const srcInfinity = srcInfExp << srcSigBits;
-    const srcSignMask = 1 << (srcSigBits + srcExpBits);
-    const srcAbsMask = srcSignMask - 1;
-    const roundMask = (1 << (srcSigBits - dstSigBits)) - 1;
-    const halfway = 1 << (srcSigBits - dstSigBits - 1);
-    const srcQNaN = 1 << (srcSigBits - 1);
-    const srcNaNCode = srcQNaN - 1;
-
-    const dstBits = @typeInfo(dst_t).Float.bits;
-    const dstExpBits = dstBits - dstSigBits - 1;
-    const dstInfExp = (1 << dstExpBits) - 1;
-    const dstExpBias = dstInfExp >> 1;
-
-    const underflowExponent = srcExpBias + 1 - dstExpBias;
-    const overflowExponent = srcExpBias + dstInfExp - dstExpBias;
-    const underflow = underflowExponent << srcSigBits;
-    const overflow = overflowExponent << srcSigBits;
-
-    const dstQNaN = 1 << (dstSigBits - 1);
-    const dstNaNCode = dstQNaN - 1;
-
-    // Break a into a sign and representation of the absolute value
-    const aRep: src_rep_t = @bitCast(src_rep_t, a);
-    const aAbs: src_rep_t = aRep & srcAbsMask;
-    const sign: src_rep_t = aRep & srcSignMask;
-    var absResult: dst_rep_t = undefined;
-
-    if (aAbs -% underflow < aAbs -% overflow) {
-        // The exponent of a is within the range of normal numbers in the
-        // destination format.  We can convert by simply right-shifting with
-        // rounding and adjusting the exponent.
-        absResult = @truncate(dst_rep_t, aAbs >> (srcSigBits - dstSigBits));
-        absResult -%= @as(dst_rep_t, srcExpBias - dstExpBias) << dstSigBits;
-
-        const roundBits: src_rep_t = aAbs & roundMask;
-        if (roundBits > halfway) {
-            // Round to nearest
-            absResult += 1;
-        } else if (roundBits == halfway) {
-            // Ties to even
-            absResult += absResult & 1;
-        }
-    } else if (aAbs > srcInfinity) {
-        // a is NaN.
-        // Conjure the result by beginning with infinity, setting the qNaN
-        // bit and inserting the (truncated) trailing NaN field.
-        absResult = @intCast(dst_rep_t, dstInfExp) << dstSigBits;
-        absResult |= dstQNaN;
-        absResult |= @intCast(dst_rep_t, ((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode);
-    } else if (aAbs >= overflow) {
-        // a overflows to infinity.
-        absResult = @intCast(dst_rep_t, dstInfExp) << dstSigBits;
-    } else {
-        // a underflows on conversion to the destination type or is an exact
-        // zero.  The result may be a denormal or zero.  Extract the exponent
-        // to get the shift amount for the denormalization.
-        const aExp = @intCast(u32, aAbs >> srcSigBits);
-        const shift = @intCast(u32, srcExpBias - dstExpBias - aExp + 1);
-
-        const significand: src_rep_t = (aRep & srcSignificandMask) | srcMinNormal;
-
-        // Right shift by the denormalization amount with sticky.
-        if (shift > srcSigBits) {
-            absResult = 0;
-        } else {
-            const sticky: src_rep_t = @boolToInt(significand << @intCast(SrcShift, srcBits - shift) != 0);
-            const denormalizedSignificand: src_rep_t = significand >> @intCast(SrcShift, shift) | sticky;
-            absResult = @intCast(dst_rep_t, denormalizedSignificand >> (srcSigBits - dstSigBits));
-            const roundBits: src_rep_t = denormalizedSignificand & roundMask;
-            if (roundBits > halfway) {
-                // Round to nearest
-                absResult += 1;
-            } else if (roundBits == halfway) {
-                // Ties to even
-                absResult += absResult & 1;
-            }
-        }
-    }
-
-    const result: dst_rep_t align(@alignOf(dst_t)) = absResult |
-        @truncate(dst_rep_t, sign >> @intCast(SrcShift, srcBits - dstBits));
-    return @bitCast(dst_t, result);
-}
-
-test {
-    _ = @import("truncXfYf2_test.zig");
-}
diff --git a/lib/compiler_rt/truncXfYf2_test.zig b/lib/compiler_rt/truncXfYf2_test.zig
deleted file mode 100644
index 3f11dd0380a63a0e8b6f4417baba09abbf1acb02..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/truncXfYf2_test.zig
+++ /dev/null
@@ -1,296 +0,0 @@
-const std = @import("std");
-const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2;
-
-fn test__truncsfhf2(a: u32, expected: u16) !void {
-    const actual = @bitCast(u16, __truncsfhf2(@bitCast(f32, a)));
-
-    if (actual == expected) {
-        return;
-    }
-
-    return error.TestFailure;
-}
-
-test "truncsfhf2" {
-    try test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN
-    try test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN
-
-    try test__truncsfhf2(0, 0); // 0
-    try test__truncsfhf2(0x80000000, 0x8000); // -0
-
-    try test__truncsfhf2(0x7f800000, 0x7c00); // inf
-    try test__truncsfhf2(0xff800000, 0xfc00); // -inf
-
-    try test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf
-    try test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf
-
-    try test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf
-    try test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf
-
-    try test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14
-    try test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14
-
-    try test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504
-    try test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504
-
-    try test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504
-    try test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504
-
-    try test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504
-    try test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504
-
-    try test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10
-    try test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10
-
-    try test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3
-    try test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3
-
-    try test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535
-    try test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535
-
-    try test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12
-
-    try test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1
-    try test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14
-
-    try test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24
-    try test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24
-
-    try test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-24
-    try test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-24
-
-    try test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20
-    try test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24
-    try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
-}
-
-const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2;
-
-fn test__truncdfhf2(a: f64, expected: u16) void {
-    const rep = @bitCast(u16, __truncdfhf2(a));
-
-    if (rep == expected) {
-        return;
-    }
-    // test other possible NaN representation(signal NaN)
-    else if (expected == 0x7e00) {
-        if ((rep & 0x7c00) == 0x7c00 and (rep & 0x3ff) > 0) {
-            return;
-        }
-    }
-
-    @panic("__truncdfhf2 test failure");
-}
-
-fn test__truncdfhf2_raw(a: u64, expected: u16) void {
-    const actual = @bitCast(u16, __truncdfhf2(@bitCast(f64, a)));
-
-    if (actual == expected) {
-        return;
-    }
-
-    @panic("__truncdfhf2 test failure");
-}
-
-test "truncdfhf2" {
-    test__truncdfhf2_raw(0x7ff8000000000000, 0x7e00); // qNaN
-    test__truncdfhf2_raw(0x7ff0000000008000, 0x7e00); // NaN
-
-    test__truncdfhf2_raw(0x7ff0000000000000, 0x7c00); //inf
-    test__truncdfhf2_raw(0xfff0000000000000, 0xfc00); // -inf
-
-    test__truncdfhf2(0.0, 0x0); // zero
-    test__truncdfhf2_raw(0x80000000 << 32, 0x8000); // -zero
-
-    test__truncdfhf2(3.1415926535, 0x4248);
-    test__truncdfhf2(-3.1415926535, 0xc248);
-
-    test__truncdfhf2(0x1.987124876876324p+1000, 0x7c00);
-    test__truncdfhf2(0x1.987124876876324p+12, 0x6e62);
-    test__truncdfhf2(0x1.0p+0, 0x3c00);
-    test__truncdfhf2(0x1.0p-14, 0x0400);
-
-    // denormal
-    test__truncdfhf2(0x1.0p-20, 0x0010);
-    test__truncdfhf2(0x1.0p-24, 0x0001);
-    test__truncdfhf2(-0x1.0p-24, 0x8001);
-    test__truncdfhf2(0x1.5p-25, 0x0001);
-
-    // and back to zero
-    test__truncdfhf2(0x1.0p-25, 0x0000);
-    test__truncdfhf2(-0x1.0p-25, 0x8000);
-
-    // max (precise)
-    test__truncdfhf2(65504.0, 0x7bff);
-
-    // max (rounded)
-    test__truncdfhf2(65519.0, 0x7bff);
-
-    // max (to +inf)
-    test__truncdfhf2(65520.0, 0x7c00);
-    test__truncdfhf2(-65520.0, 0xfc00);
-    test__truncdfhf2(65536.0, 0x7c00);
-}
-
-const __trunctfsf2 = @import("truncXfYf2.zig").__trunctfsf2;
-
-fn test__trunctfsf2(a: f128, expected: u32) void {
-    const x = __trunctfsf2(a);
-
-    const rep = @bitCast(u32, x);
-    if (rep == expected) {
-        return;
-    }
-    // test other possible NaN representation(signal NaN)
-    else if (expected == 0x7fc00000) {
-        if ((rep & 0x7f800000) == 0x7f800000 and (rep & 0x7fffff) > 0) {
-            return;
-        }
-    }
-
-    @panic("__trunctfsf2 test failure");
-}
-
-test "trunctfsf2" {
-    // qnan
-    test__trunctfsf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7fc00000);
-    // nan
-    test__trunctfsf2(@bitCast(f128, @as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7fc08000);
-    // inf
-    test__trunctfsf2(@bitCast(f128, @as(u128, 0x7fff000000000000 << 64)), 0x7f800000);
-    // zero
-    test__trunctfsf2(0.0, 0x0);
-
-    test__trunctfsf2(0x1.23a2abb4a2ddee355f36789abcdep+5, 0x4211d156);
-    test__trunctfsf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9, 0x3b71e9e2);
-    test__trunctfsf2(0x1.234eebb5faa678f4488693abcdefp+4534, 0x7f800000);
-    test__trunctfsf2(0x1.edcba9bb8c76a5a43dd21f334634p-435, 0x0);
-}
-
-const __trunctfdf2 = @import("truncXfYf2.zig").__trunctfdf2;
-
-fn test__trunctfdf2(a: f128, expected: u64) void {
-    const x = __trunctfdf2(a);
-
-    const rep = @bitCast(u64, x);
-    if (rep == expected) {
-        return;
-    }
-    // test other possible NaN representation(signal NaN)
-    else if (expected == 0x7ff8000000000000) {
-        if ((rep & 0x7ff0000000000000) == 0x7ff0000000000000 and (rep & 0xfffffffffffff) > 0) {
-            return;
-        }
-    }
-
-    @panic("__trunctfsf2 test failure");
-}
-
-test "trunctfdf2" {
-    // qnan
-    test__trunctfdf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7ff8000000000000);
-    // nan
-    test__trunctfdf2(@bitCast(f128, @as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7ff8100000000000);
-    // inf
-    test__trunctfdf2(@bitCast(f128, @as(u128, 0x7fff000000000000 << 64)), 0x7ff0000000000000);
-    // zero
-    test__trunctfdf2(0.0, 0x0);
-
-    test__trunctfdf2(0x1.af23456789bbaaab347645365cdep+5, 0x404af23456789bbb);
-    test__trunctfdf2(0x1.dedafcff354b6ae9758763545432p-9, 0x3f6dedafcff354b7);
-    test__trunctfdf2(0x1.2f34dd5f437e849b4baab754cdefp+4534, 0x7ff0000000000000);
-    test__trunctfdf2(0x1.edcbff8ad76ab5bf46463233214fp-435, 0x24cedcbff8ad76ab);
-}
-
-const __truncdfsf2 = @import("truncXfYf2.zig").__truncdfsf2;
-
-fn test__truncdfsf2(a: f64, expected: u32) void {
-    const x = __truncdfsf2(a);
-
-    const rep = @bitCast(u32, x);
-    if (rep == expected) {
-        return;
-    }
-    // test other possible NaN representation(signal NaN)
-    else if (expected == 0x7fc00000) {
-        if ((rep & 0x7f800000) == 0x7f800000 and (rep & 0x7fffff) > 0) {
-            return;
-        }
-    }
-
-    std.debug.print("got 0x{x} wanted 0x{x}\n", .{ rep, expected });
-
-    @panic("__trunctfsf2 test failure");
-}
-
-test "truncdfsf2" {
-    // nan & qnan
-    test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff8000000000000)), 0x7fc00000);
-    test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff0000000000001)), 0x7fc00000);
-    // inf
-    test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff0000000000000)), 0x7f800000);
-    test__truncdfsf2(@bitCast(f64, @as(u64, 0xfff0000000000000)), 0xff800000);
-
-    test__truncdfsf2(0.0, 0x0);
-    test__truncdfsf2(1.0, 0x3f800000);
-    test__truncdfsf2(-1.0, 0xbf800000);
-
-    // huge number becomes inf
-    test__truncdfsf2(340282366920938463463374607431768211456.0, 0x7f800000);
-}
-
-const __trunctfhf2 = @import("truncXfYf2.zig").__trunctfhf2;
-
-fn test__trunctfhf2(a: f128, expected: u16) void {
-    const x = __trunctfhf2(a);
-
-    const rep = @bitCast(u16, x);
-    if (rep == expected) {
-        return;
-    }
-
-    std.debug.print("got 0x{x} wanted 0x{x}\n", .{ rep, expected });
-
-    @panic("__trunctfhf2 test failure");
-}
-
-test "trunctfhf2" {
-    // qNaN
-    test__trunctfhf2(@bitCast(f128, @as(u128, 0x7fff8000000000000000000000000000)), 0x7e00);
-    // NaN
-    test__trunctfhf2(@bitCast(f128, @as(u128, 0x7fff0000000000000000000000000001)), 0x7e00);
-    // inf
-    test__trunctfhf2(@bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)), 0x7c00);
-    test__trunctfhf2(-@bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)), 0xfc00);
-    // zero
-    test__trunctfhf2(0.0, 0x0);
-    test__trunctfhf2(-0.0, 0x8000);
-
-    test__trunctfhf2(3.1415926535, 0x4248);
-    test__trunctfhf2(-3.1415926535, 0xc248);
-    test__trunctfhf2(0x1.987124876876324p+100, 0x7c00);
-    test__trunctfhf2(0x1.987124876876324p+12, 0x6e62);
-    test__trunctfhf2(0x1.0p+0, 0x3c00);
-    test__trunctfhf2(0x1.0p-14, 0x0400);
-    // denormal
-    test__trunctfhf2(0x1.0p-20, 0x0010);
-    test__trunctfhf2(0x1.0p-24, 0x0001);
-    test__trunctfhf2(-0x1.0p-24, 0x8001);
-    test__trunctfhf2(0x1.5p-25, 0x0001);
-    // and back to zero
-    test__trunctfhf2(0x1.0p-25, 0x0000);
-    test__trunctfhf2(-0x1.0p-25, 0x8000);
-    // max (precise)
-    test__trunctfhf2(65504.0, 0x7bff);
-    // max (rounded)
-    test__trunctfhf2(65519.0, 0x7bff);
-    // max (to +inf)
-    test__trunctfhf2(65520.0, 0x7c00);
-    test__trunctfhf2(65536.0, 0x7c00);
-    test__trunctfhf2(-65520.0, 0xfc00);
-
-    test__trunctfhf2(0x1.23a2abb4a2ddee355f36789abcdep+5, 0x508f);
-    test__trunctfhf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9, 0x1b8f);
-    test__trunctfhf2(0x1.234eebb5faa678f4488693abcdefp+453, 0x7c00);
-    test__trunctfhf2(0x1.edcba9bb8c76a5a43dd21f334634p-43, 0x0);
-}
diff --git a/lib/compiler_rt/trunc_f80.zig b/lib/compiler_rt/trunc_f80.zig
deleted file mode 100644
index 43f113ea42a17a1b479cd021cbb597a8ac28cfe0..0000000000000000000000000000000000000000
--- a/lib/compiler_rt/trunc_f80.zig
+++ /dev/null
@@ -1,183 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const arch = builtin.cpu.arch;
-const testing = std.testing;
-const is_test = builtin.is_test;
-const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
-pub const panic = @import("common.zig").panic;
-
-comptime {
-    @export(__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = linkage });
-    @export(__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = linkage });
-    @export(__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = linkage });
-    @export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = linkage });
-}
-
-// AArch64 is the only ABI (at the moment) to support f16 arguments without the
-// need for extending them to wider fp types.
-const F16T = if (arch.isAARCH64()) f16 else u16;
-
-pub fn __truncxfhf2(a: f80) callconv(.C) F16T {
-    return @bitCast(F16T, trunc(f16, a));
-}
-
-pub fn __truncxfsf2(a: f80) callconv(.C) f32 {
-    return trunc(f32, a);
-}
-
-pub fn __truncxfdf2(a: f80) callconv(.C) f64 {
-    return trunc(f64, a);
-}
-
-inline fn trunc(comptime dst_t: type, a: f80) dst_t {
-    @setRuntimeSafety(builtin.is_test);
-
-    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
-    const src_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
-    const dst_sig_bits = std.math.floatMantissaBits(dst_t);
-
-    const src_exp_bias = 16383;
-
-    const round_mask = (1 << (src_sig_bits - dst_sig_bits)) - 1;
-    const halfway = 1 << (src_sig_bits - dst_sig_bits - 1);
-
-    const dst_bits = @typeInfo(dst_t).Float.bits;
-    const dst_exp_bits = dst_bits - dst_sig_bits - 1;
-    const dst_inf_exp = (1 << dst_exp_bits) - 1;
-    const dst_exp_bias = dst_inf_exp >> 1;
-
-    const underflow = src_exp_bias + 1 - dst_exp_bias;
-    const overflow = src_exp_bias + dst_inf_exp - dst_exp_bias;
-
-    const dst_qnan = 1 << (dst_sig_bits - 1);
-    const dst_nan_mask = dst_qnan - 1;
-
-    // Break a into a sign and representation of the absolute value
-    var a_rep = std.math.break_f80(a);
-    const sign = a_rep.exp & 0x8000;
-    a_rep.exp &= 0x7FFF;
-    a_rep.fraction &= 0x7FFFFFFFFFFFFFFF;
-    var abs_result: dst_rep_t = undefined;
-
-    if (a_rep.exp -% underflow < a_rep.exp -% overflow) {
-        // The exponent of a is within the range of normal numbers in the
-        // destination format.  We can convert by simply right-shifting with
-        // rounding and adjusting the exponent.
-        abs_result = @as(dst_rep_t, a_rep.exp) << dst_sig_bits;
-        abs_result |= @truncate(dst_rep_t, a_rep.fraction >> (src_sig_bits - dst_sig_bits));
-        abs_result -%= @as(dst_rep_t, src_exp_bias - dst_exp_bias) << dst_sig_bits;
-
-        const round_bits = a_rep.fraction & round_mask;
-        if (round_bits > halfway) {
-            // Round to nearest
-            abs_result += 1;
-        } else if (round_bits == halfway) {
-            // Ties to even
-            abs_result += abs_result & 1;
-        }
-    } else if (a_rep.exp == 0x7FFF and a_rep.fraction != 0) {
-        // a is NaN.
-        // Conjure the result by beginning with infinity, setting the qNaN
-        // bit and inserting the (truncated) trailing NaN field.
-        abs_result = @intCast(dst_rep_t, dst_inf_exp) << dst_sig_bits;
-        abs_result |= dst_qnan;
-        abs_result |= @intCast(dst_rep_t, (a_rep.fraction >> (src_sig_bits - dst_sig_bits)) & dst_nan_mask);
-    } else if (a_rep.exp >= overflow) {
-        // a overflows to infinity.
-        abs_result = @intCast(dst_rep_t, dst_inf_exp) << dst_sig_bits;
-    } else {
-        // a underflows on conversion to the destination type or is an exact
-        // zero.  The result may be a denormal or zero.  Extract the exponent
-        // to get the shift amount for the denormalization.
-        const shift = src_exp_bias - dst_exp_bias - a_rep.exp;
-
-        // Right shift by the denormalization amount with sticky.
-        if (shift > src_sig_bits) {
-            abs_result = 0;
-        } else {
-            const sticky = @boolToInt(a_rep.fraction << @intCast(u6, shift) != 0);
-            const denormalized_significand = a_rep.fraction >> @intCast(u6, shift) | sticky;
-            abs_result = @intCast(dst_rep_t, denormalized_significand >> (src_sig_bits - dst_sig_bits));
-            const round_bits = denormalized_significand & round_mask;
-            if (round_bits > halfway) {
-                // Round to nearest
-                abs_result += 1;
-            } else if (round_bits == halfway) {
-                // Ties to even
-                abs_result += abs_result & 1;
-            }
-        }
-    }
-
-    const result align(@alignOf(dst_t)) = abs_result | @as(dst_rep_t, sign) << dst_bits - 16;
-    return @bitCast(dst_t, result);
-}
-
-pub fn __trunctfxf2(a: f128) callconv(.C) f80 {
-    const src_sig_bits = std.math.floatMantissaBits(f128);
-    const dst_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
-
-    // Various constants whose values follow from the type parameters.
-    // Any reasonable optimizer will fold and propagate all of these.
-    const src_bits = @typeInfo(f128).Float.bits;
-    const src_exp_bits = src_bits - src_sig_bits - 1;
-    const src_inf_exp = 0x7FFF;
-
-    const src_inf = src_inf_exp << src_sig_bits;
-    const src_sign_mask = 1 << (src_sig_bits + src_exp_bits);
-    const src_abs_mask = src_sign_mask - 1;
-    const round_mask = (1 << (src_sig_bits - dst_sig_bits)) - 1;
-    const halfway = 1 << (src_sig_bits - dst_sig_bits - 1);
-
-    // Break a into a sign and representation of the absolute value
-    const a_rep = @bitCast(u128, a);
-    const a_abs = a_rep & src_abs_mask;
-    const sign: u16 = if (a_rep & src_sign_mask != 0) 0x8000 else 0;
-    const integer_bit = 1 << 63;
-
-    var res: std.math.F80 = undefined;
-
-    if (a_abs > src_inf) {
-        // a is NaN.
-        // Conjure the result by beginning with infinity, setting the qNaN
-        // bit and inserting the (truncated) trailing NaN field.
-        res.exp = 0x7fff;
-        res.fraction = 0x8000000000000000;
-        res.fraction |= @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits));
-    } else {
-        // The exponent of a is within the range of normal numbers in the
-        // destination format.  We can convert by simply right-shifting with
-        // rounding, adding the explicit integer bit, and adjusting the exponent
-        res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits)) | integer_bit;
-        res.exp = @truncate(u16, a_abs >> src_sig_bits);
-
-        const round_bits = a_abs & round_mask;
-        if (round_bits > halfway) {
-            // Round to nearest
-            const carry = @boolToInt(@addWithOverflow(u64, res.fraction, 1, &res.fraction));
-            res.exp += carry;
-            res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry
-        } else if (round_bits == halfway) {
-            // Ties to even
-            const carry = @boolToInt(@addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction));
-            res.exp += carry;
-            res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry
-        }
-        if (res.exp == 0) res.fraction &= ~@as(u64, integer_bit); // Remove integer bit for de-normals
-    }
-
-    res.exp |= sign;
-    return std.math.make_f80(res);
-}
-
-fn test__trunctfxf2(a: f128, expected: f80) !void {
-    const x = __trunctfxf2(a);
-    try testing.expect(x == expected);
-}
-
-test {
-    try test__trunctfxf2(1.5, 1.5);
-    try test__trunctfxf2(2.5, 2.5);
-    try test__trunctfxf2(-2.5, -2.5);
-    try test__trunctfxf2(0.0, 0.0);
-}
diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..6d4135d249c0aa96a7534540f8b22f37eb148e87
--- /dev/null
+++ b/lib/compiler_rt/truncdfhf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const truncf = @import("./truncf.zig").truncf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage });
+    } else {
+        @export(__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage });
+    }
+}
+
+fn __truncdfhf2(a: f64) callconv(.C) common.F16T {
+    return @bitCast(common.F16T, truncf(f16, f64, a));
+}
+
+fn __aeabi_d2h(a: f64) callconv(.AAPCS) u16 {
+    return @bitCast(common.F16T, truncf(f16, f64, a));
+}
diff --git a/lib/compiler_rt/truncdfsf2.zig b/lib/compiler_rt/truncdfsf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..adf770582192b4076cb71e7a4fc511190946b92f
--- /dev/null
+++ b/lib/compiler_rt/truncdfsf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const truncf = @import("./truncf.zig").truncf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_d2f, .{ .name = "__aeabi_d2f", .linkage = common.linkage });
+    } else {
+        @export(__truncdfsf2, .{ .name = "__truncdfsf2", .linkage = common.linkage });
+    }
+}
+
+fn __truncdfsf2(a: f64) callconv(.C) f32 {
+    return truncf(f32, f64, a);
+}
+
+fn __aeabi_d2f(a: f64) callconv(.AAPCS) f32 {
+    return truncf(f32, f64, a);
+}
diff --git a/lib/compiler_rt/truncf.zig b/lib/compiler_rt/truncf.zig
new file mode 100644
index 0000000000000000000000000000000000000000..c012bcee621fb05649ec38427bb97a71437dae1f
--- /dev/null
+++ b/lib/compiler_rt/truncf.zig
@@ -0,0 +1,187 @@
+const std = @import("std");
+
+pub inline fn truncf(comptime dst_t: type, comptime src_t: type, a: src_t) dst_t {
+    const src_rep_t = std.meta.Int(.unsigned, @typeInfo(src_t).Float.bits);
+    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
+    const srcSigBits = std.math.floatMantissaBits(src_t);
+    const dstSigBits = std.math.floatMantissaBits(dst_t);
+    const SrcShift = std.math.Log2Int(src_rep_t);
+
+    // Various constants whose values follow from the type parameters.
+    // Any reasonable optimizer will fold and propagate all of these.
+    const srcBits = @typeInfo(src_t).Float.bits;
+    const srcExpBits = srcBits - srcSigBits - 1;
+    const srcInfExp = (1 << srcExpBits) - 1;
+    const srcExpBias = srcInfExp >> 1;
+
+    const srcMinNormal = 1 << srcSigBits;
+    const srcSignificandMask = srcMinNormal - 1;
+    const srcInfinity = srcInfExp << srcSigBits;
+    const srcSignMask = 1 << (srcSigBits + srcExpBits);
+    const srcAbsMask = srcSignMask - 1;
+    const roundMask = (1 << (srcSigBits - dstSigBits)) - 1;
+    const halfway = 1 << (srcSigBits - dstSigBits - 1);
+    const srcQNaN = 1 << (srcSigBits - 1);
+    const srcNaNCode = srcQNaN - 1;
+
+    const dstBits = @typeInfo(dst_t).Float.bits;
+    const dstExpBits = dstBits - dstSigBits - 1;
+    const dstInfExp = (1 << dstExpBits) - 1;
+    const dstExpBias = dstInfExp >> 1;
+
+    const underflowExponent = srcExpBias + 1 - dstExpBias;
+    const overflowExponent = srcExpBias + dstInfExp - dstExpBias;
+    const underflow = underflowExponent << srcSigBits;
+    const overflow = overflowExponent << srcSigBits;
+
+    const dstQNaN = 1 << (dstSigBits - 1);
+    const dstNaNCode = dstQNaN - 1;
+
+    // Break a into a sign and representation of the absolute value
+    const aRep: src_rep_t = @bitCast(src_rep_t, a);
+    const aAbs: src_rep_t = aRep & srcAbsMask;
+    const sign: src_rep_t = aRep & srcSignMask;
+    var absResult: dst_rep_t = undefined;
+
+    if (aAbs -% underflow < aAbs -% overflow) {
+        // The exponent of a is within the range of normal numbers in the
+        // destination format.  We can convert by simply right-shifting with
+        // rounding and adjusting the exponent.
+        absResult = @truncate(dst_rep_t, aAbs >> (srcSigBits - dstSigBits));
+        absResult -%= @as(dst_rep_t, srcExpBias - dstExpBias) << dstSigBits;
+
+        const roundBits: src_rep_t = aAbs & roundMask;
+        if (roundBits > halfway) {
+            // Round to nearest
+            absResult += 1;
+        } else if (roundBits == halfway) {
+            // Ties to even
+            absResult += absResult & 1;
+        }
+    } else if (aAbs > srcInfinity) {
+        // a is NaN.
+        // Conjure the result by beginning with infinity, setting the qNaN
+        // bit and inserting the (truncated) trailing NaN field.
+        absResult = @intCast(dst_rep_t, dstInfExp) << dstSigBits;
+        absResult |= dstQNaN;
+        absResult |= @intCast(dst_rep_t, ((aAbs & srcNaNCode) >> (srcSigBits - dstSigBits)) & dstNaNCode);
+    } else if (aAbs >= overflow) {
+        // a overflows to infinity.
+        absResult = @intCast(dst_rep_t, dstInfExp) << dstSigBits;
+    } else {
+        // a underflows on conversion to the destination type or is an exact
+        // zero.  The result may be a denormal or zero.  Extract the exponent
+        // to get the shift amount for the denormalization.
+        const aExp = @intCast(u32, aAbs >> srcSigBits);
+        const shift = @intCast(u32, srcExpBias - dstExpBias - aExp + 1);
+
+        const significand: src_rep_t = (aRep & srcSignificandMask) | srcMinNormal;
+
+        // Right shift by the denormalization amount with sticky.
+        if (shift > srcSigBits) {
+            absResult = 0;
+        } else {
+            const sticky: src_rep_t = @boolToInt(significand << @intCast(SrcShift, srcBits - shift) != 0);
+            const denormalizedSignificand: src_rep_t = significand >> @intCast(SrcShift, shift) | sticky;
+            absResult = @intCast(dst_rep_t, denormalizedSignificand >> (srcSigBits - dstSigBits));
+            const roundBits: src_rep_t = denormalizedSignificand & roundMask;
+            if (roundBits > halfway) {
+                // Round to nearest
+                absResult += 1;
+            } else if (roundBits == halfway) {
+                // Ties to even
+                absResult += absResult & 1;
+            }
+        }
+    }
+
+    const result: dst_rep_t align(@alignOf(dst_t)) = absResult |
+        @truncate(dst_rep_t, sign >> @intCast(SrcShift, srcBits - dstBits));
+    return @bitCast(dst_t, result);
+}
+
+pub inline fn trunc_f80(comptime dst_t: type, a: f80) dst_t {
+    const dst_rep_t = std.meta.Int(.unsigned, @typeInfo(dst_t).Float.bits);
+    const src_sig_bits = std.math.floatMantissaBits(f80) - 1; // -1 for the integer bit
+    const dst_sig_bits = std.math.floatMantissaBits(dst_t);
+
+    const src_exp_bias = 16383;
+
+    const round_mask = (1 << (src_sig_bits - dst_sig_bits)) - 1;
+    const halfway = 1 << (src_sig_bits - dst_sig_bits - 1);
+
+    const dst_bits = @typeInfo(dst_t).Float.bits;
+    const dst_exp_bits = dst_bits - dst_sig_bits - 1;
+    const dst_inf_exp = (1 << dst_exp_bits) - 1;
+    const dst_exp_bias = dst_inf_exp >> 1;
+
+    const underflow = src_exp_bias + 1 - dst_exp_bias;
+    const overflow = src_exp_bias + dst_inf_exp - dst_exp_bias;
+
+    const dst_qnan = 1 << (dst_sig_bits - 1);
+    const dst_nan_mask = dst_qnan - 1;
+
+    // Break a into a sign and representation of the absolute value
+    var a_rep = std.math.break_f80(a);
+    const sign = a_rep.exp & 0x8000;
+    a_rep.exp &= 0x7FFF;
+    a_rep.fraction &= 0x7FFFFFFFFFFFFFFF;
+    var abs_result: dst_rep_t = undefined;
+
+    if (a_rep.exp -% underflow < a_rep.exp -% overflow) {
+        // The exponent of a is within the range of normal numbers in the
+        // destination format.  We can convert by simply right-shifting with
+        // rounding and adjusting the exponent.
+        abs_result = @as(dst_rep_t, a_rep.exp) << dst_sig_bits;
+        abs_result |= @truncate(dst_rep_t, a_rep.fraction >> (src_sig_bits - dst_sig_bits));
+        abs_result -%= @as(dst_rep_t, src_exp_bias - dst_exp_bias) << dst_sig_bits;
+
+        const round_bits = a_rep.fraction & round_mask;
+        if (round_bits > halfway) {
+            // Round to nearest
+            abs_result += 1;
+        } else if (round_bits == halfway) {
+            // Ties to even
+            abs_result += abs_result & 1;
+        }
+    } else if (a_rep.exp == 0x7FFF and a_rep.fraction != 0) {
+        // a is NaN.
+        // Conjure the result by beginning with infinity, setting the qNaN
+        // bit and inserting the (truncated) trailing NaN field.
+        abs_result = @intCast(dst_rep_t, dst_inf_exp) << dst_sig_bits;
+        abs_result |= dst_qnan;
+        abs_result |= @intCast(dst_rep_t, (a_rep.fraction >> (src_sig_bits - dst_sig_bits)) & dst_nan_mask);
+    } else if (a_rep.exp >= overflow) {
+        // a overflows to infinity.
+        abs_result = @intCast(dst_rep_t, dst_inf_exp) << dst_sig_bits;
+    } else {
+        // a underflows on conversion to the destination type or is an exact
+        // zero.  The result may be a denormal or zero.  Extract the exponent
+        // to get the shift amount for the denormalization.
+        const shift = src_exp_bias - dst_exp_bias - a_rep.exp;
+
+        // Right shift by the denormalization amount with sticky.
+        if (shift > src_sig_bits) {
+            abs_result = 0;
+        } else {
+            const sticky = @boolToInt(a_rep.fraction << @intCast(u6, shift) != 0);
+            const denormalized_significand = a_rep.fraction >> @intCast(u6, shift) | sticky;
+            abs_result = @intCast(dst_rep_t, denormalized_significand >> (src_sig_bits - dst_sig_bits));
+            const round_bits = denormalized_significand & round_mask;
+            if (round_bits > halfway) {
+                // Round to nearest
+                abs_result += 1;
+            } else if (round_bits == halfway) {
+                // Ties to even
+                abs_result += abs_result & 1;
+            }
+        }
+    }
+
+    const result align(@alignOf(dst_t)) = abs_result | @as(dst_rep_t, sign) << dst_bits - 16;
+    return @bitCast(dst_t, result);
+}
+
+test {
+    _ = @import("truncf_test.zig");
+}
diff --git a/lib/compiler_rt/truncf_test.zig b/lib/compiler_rt/truncf_test.zig
new file mode 100644
index 0000000000000000000000000000000000000000..58c02a0a211bc22eb913eeab9863745a4db24450
--- /dev/null
+++ b/lib/compiler_rt/truncf_test.zig
@@ -0,0 +1,310 @@
+const std = @import("std");
+const testing = std.testing;
+const __truncsfhf2 = @import("truncXfYf2.zig").__truncsfhf2;
+const __trunctfxf2 = @import("trunctfxf2.zig").__trunctfxf2;
+
+fn test__truncsfhf2(a: u32, expected: u16) !void {
+    const actual = @bitCast(u16, __truncsfhf2(@bitCast(f32, a)));
+
+    if (actual == expected) {
+        return;
+    }
+
+    return error.TestFailure;
+}
+
+test "truncsfhf2" {
+    try test__truncsfhf2(0x7fc00000, 0x7e00); // qNaN
+    try test__truncsfhf2(0x7fe00000, 0x7f00); // sNaN
+
+    try test__truncsfhf2(0, 0); // 0
+    try test__truncsfhf2(0x80000000, 0x8000); // -0
+
+    try test__truncsfhf2(0x7f800000, 0x7c00); // inf
+    try test__truncsfhf2(0xff800000, 0xfc00); // -inf
+
+    try test__truncsfhf2(0x477ff000, 0x7c00); // 65520 -> inf
+    try test__truncsfhf2(0xc77ff000, 0xfc00); // -65520 -> -inf
+
+    try test__truncsfhf2(0x71cc3892, 0x7c00); // 0x1.987124876876324p+100 -> inf
+    try test__truncsfhf2(0xf1cc3892, 0xfc00); // -0x1.987124876876324p+100 -> -inf
+
+    try test__truncsfhf2(0x38800000, 0x0400); // normal (min), 2**-14
+    try test__truncsfhf2(0xb8800000, 0x8400); // normal (min), -2**-14
+
+    try test__truncsfhf2(0x477fe000, 0x7bff); // normal (max), 65504
+    try test__truncsfhf2(0xc77fe000, 0xfbff); // normal (max), -65504
+
+    try test__truncsfhf2(0x477fe100, 0x7bff); // normal, 65505 -> 65504
+    try test__truncsfhf2(0xc77fe100, 0xfbff); // normal, -65505 -> -65504
+
+    try test__truncsfhf2(0x477fef00, 0x7bff); // normal, 65519 -> 65504
+    try test__truncsfhf2(0xc77fef00, 0xfbff); // normal, -65519 -> -65504
+
+    try test__truncsfhf2(0x3f802000, 0x3c01); // normal, 1 + 2**-10
+    try test__truncsfhf2(0xbf802000, 0xbc01); // normal, -1 - 2**-10
+
+    try test__truncsfhf2(0x3eaaa000, 0x3555); // normal, approx. 1/3
+    try test__truncsfhf2(0xbeaaa000, 0xb555); // normal, approx. -1/3
+
+    try test__truncsfhf2(0x40490fdb, 0x4248); // normal, 3.1415926535
+    try test__truncsfhf2(0xc0490fdb, 0xc248); // normal, -3.1415926535
+
+    try test__truncsfhf2(0x45cc3892, 0x6e62); // normal, 0x1.987124876876324p+12
+
+    try test__truncsfhf2(0x3f800000, 0x3c00); // normal, 1
+    try test__truncsfhf2(0x38800000, 0x0400); // normal, 0x1.0p-14
+
+    try test__truncsfhf2(0x33800000, 0x0001); // denormal (min), 2**-24
+    try test__truncsfhf2(0xb3800000, 0x8001); // denormal (min), -2**-24
+
+    try test__truncsfhf2(0x387fc000, 0x03ff); // denormal (max), 2**-14 - 2**-24
+    try test__truncsfhf2(0xb87fc000, 0x83ff); // denormal (max), -2**-14 + 2**-24
+
+    try test__truncsfhf2(0x35800000, 0x0010); // denormal, 0x1.0p-20
+    try test__truncsfhf2(0x33280000, 0x0001); // denormal, 0x1.5p-25 -> 0x1.0p-24
+    try test__truncsfhf2(0x33000000, 0x0000); // 0x1.0p-25 -> zero
+}
+
+const __truncdfhf2 = @import("truncXfYf2.zig").__truncdfhf2;
+
+fn test__truncdfhf2(a: f64, expected: u16) void {
+    const rep = @bitCast(u16, __truncdfhf2(a));
+
+    if (rep == expected) {
+        return;
+    }
+    // test other possible NaN representation(signal NaN)
+    else if (expected == 0x7e00) {
+        if ((rep & 0x7c00) == 0x7c00 and (rep & 0x3ff) > 0) {
+            return;
+        }
+    }
+
+    @panic("__truncdfhf2 test failure");
+}
+
+fn test__truncdfhf2_raw(a: u64, expected: u16) void {
+    const actual = @bitCast(u16, __truncdfhf2(@bitCast(f64, a)));
+
+    if (actual == expected) {
+        return;
+    }
+
+    @panic("__truncdfhf2 test failure");
+}
+
+test "truncdfhf2" {
+    test__truncdfhf2_raw(0x7ff8000000000000, 0x7e00); // qNaN
+    test__truncdfhf2_raw(0x7ff0000000008000, 0x7e00); // NaN
+
+    test__truncdfhf2_raw(0x7ff0000000000000, 0x7c00); //inf
+    test__truncdfhf2_raw(0xfff0000000000000, 0xfc00); // -inf
+
+    test__truncdfhf2(0.0, 0x0); // zero
+    test__truncdfhf2_raw(0x80000000 << 32, 0x8000); // -zero
+
+    test__truncdfhf2(3.1415926535, 0x4248);
+    test__truncdfhf2(-3.1415926535, 0xc248);
+
+    test__truncdfhf2(0x1.987124876876324p+1000, 0x7c00);
+    test__truncdfhf2(0x1.987124876876324p+12, 0x6e62);
+    test__truncdfhf2(0x1.0p+0, 0x3c00);
+    test__truncdfhf2(0x1.0p-14, 0x0400);
+
+    // denormal
+    test__truncdfhf2(0x1.0p-20, 0x0010);
+    test__truncdfhf2(0x1.0p-24, 0x0001);
+    test__truncdfhf2(-0x1.0p-24, 0x8001);
+    test__truncdfhf2(0x1.5p-25, 0x0001);
+
+    // and back to zero
+    test__truncdfhf2(0x1.0p-25, 0x0000);
+    test__truncdfhf2(-0x1.0p-25, 0x8000);
+
+    // max (precise)
+    test__truncdfhf2(65504.0, 0x7bff);
+
+    // max (rounded)
+    test__truncdfhf2(65519.0, 0x7bff);
+
+    // max (to +inf)
+    test__truncdfhf2(65520.0, 0x7c00);
+    test__truncdfhf2(-65520.0, 0xfc00);
+    test__truncdfhf2(65536.0, 0x7c00);
+}
+
+const __trunctfsf2 = @import("truncXfYf2.zig").__trunctfsf2;
+
+fn test__trunctfsf2(a: f128, expected: u32) void {
+    const x = __trunctfsf2(a);
+
+    const rep = @bitCast(u32, x);
+    if (rep == expected) {
+        return;
+    }
+    // test other possible NaN representation(signal NaN)
+    else if (expected == 0x7fc00000) {
+        if ((rep & 0x7f800000) == 0x7f800000 and (rep & 0x7fffff) > 0) {
+            return;
+        }
+    }
+
+    @panic("__trunctfsf2 test failure");
+}
+
+test "trunctfsf2" {
+    // qnan
+    test__trunctfsf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7fc00000);
+    // nan
+    test__trunctfsf2(@bitCast(f128, @as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7fc08000);
+    // inf
+    test__trunctfsf2(@bitCast(f128, @as(u128, 0x7fff000000000000 << 64)), 0x7f800000);
+    // zero
+    test__trunctfsf2(0.0, 0x0);
+
+    test__trunctfsf2(0x1.23a2abb4a2ddee355f36789abcdep+5, 0x4211d156);
+    test__trunctfsf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9, 0x3b71e9e2);
+    test__trunctfsf2(0x1.234eebb5faa678f4488693abcdefp+4534, 0x7f800000);
+    test__trunctfsf2(0x1.edcba9bb8c76a5a43dd21f334634p-435, 0x0);
+}
+
+const __trunctfdf2 = @import("truncXfYf2.zig").__trunctfdf2;
+
+fn test__trunctfdf2(a: f128, expected: u64) void {
+    const x = __trunctfdf2(a);
+
+    const rep = @bitCast(u64, x);
+    if (rep == expected) {
+        return;
+    }
+    // test other possible NaN representation(signal NaN)
+    else if (expected == 0x7ff8000000000000) {
+        if ((rep & 0x7ff0000000000000) == 0x7ff0000000000000 and (rep & 0xfffffffffffff) > 0) {
+            return;
+        }
+    }
+
+    @panic("__trunctfsf2 test failure");
+}
+
+test "trunctfdf2" {
+    // qnan
+    test__trunctfdf2(@bitCast(f128, @as(u128, 0x7fff800000000000 << 64)), 0x7ff8000000000000);
+    // nan
+    test__trunctfdf2(@bitCast(f128, @as(u128, (0x7fff000000000000 | (0x810000000000 & 0xffffffffffff)) << 64)), 0x7ff8100000000000);
+    // inf
+    test__trunctfdf2(@bitCast(f128, @as(u128, 0x7fff000000000000 << 64)), 0x7ff0000000000000);
+    // zero
+    test__trunctfdf2(0.0, 0x0);
+
+    test__trunctfdf2(0x1.af23456789bbaaab347645365cdep+5, 0x404af23456789bbb);
+    test__trunctfdf2(0x1.dedafcff354b6ae9758763545432p-9, 0x3f6dedafcff354b7);
+    test__trunctfdf2(0x1.2f34dd5f437e849b4baab754cdefp+4534, 0x7ff0000000000000);
+    test__trunctfdf2(0x1.edcbff8ad76ab5bf46463233214fp-435, 0x24cedcbff8ad76ab);
+}
+
+const __truncdfsf2 = @import("truncXfYf2.zig").__truncdfsf2;
+
+fn test__truncdfsf2(a: f64, expected: u32) void {
+    const x = __truncdfsf2(a);
+
+    const rep = @bitCast(u32, x);
+    if (rep == expected) {
+        return;
+    }
+    // test other possible NaN representation(signal NaN)
+    else if (expected == 0x7fc00000) {
+        if ((rep & 0x7f800000) == 0x7f800000 and (rep & 0x7fffff) > 0) {
+            return;
+        }
+    }
+
+    std.debug.print("got 0x{x} wanted 0x{x}\n", .{ rep, expected });
+
+    @panic("__trunctfsf2 test failure");
+}
+
+test "truncdfsf2" {
+    // nan & qnan
+    test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff8000000000000)), 0x7fc00000);
+    test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff0000000000001)), 0x7fc00000);
+    // inf
+    test__truncdfsf2(@bitCast(f64, @as(u64, 0x7ff0000000000000)), 0x7f800000);
+    test__truncdfsf2(@bitCast(f64, @as(u64, 0xfff0000000000000)), 0xff800000);
+
+    test__truncdfsf2(0.0, 0x0);
+    test__truncdfsf2(1.0, 0x3f800000);
+    test__truncdfsf2(-1.0, 0xbf800000);
+
+    // huge number becomes inf
+    test__truncdfsf2(340282366920938463463374607431768211456.0, 0x7f800000);
+}
+
+const __trunctfhf2 = @import("truncXfYf2.zig").__trunctfhf2;
+
+fn test__trunctfhf2(a: f128, expected: u16) void {
+    const x = __trunctfhf2(a);
+
+    const rep = @bitCast(u16, x);
+    if (rep == expected) {
+        return;
+    }
+
+    std.debug.print("got 0x{x} wanted 0x{x}\n", .{ rep, expected });
+
+    @panic("__trunctfhf2 test failure");
+}
+
+test "trunctfhf2" {
+    // qNaN
+    test__trunctfhf2(@bitCast(f128, @as(u128, 0x7fff8000000000000000000000000000)), 0x7e00);
+    // NaN
+    test__trunctfhf2(@bitCast(f128, @as(u128, 0x7fff0000000000000000000000000001)), 0x7e00);
+    // inf
+    test__trunctfhf2(@bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)), 0x7c00);
+    test__trunctfhf2(-@bitCast(f128, @as(u128, 0x7fff0000000000000000000000000000)), 0xfc00);
+    // zero
+    test__trunctfhf2(0.0, 0x0);
+    test__trunctfhf2(-0.0, 0x8000);
+
+    test__trunctfhf2(3.1415926535, 0x4248);
+    test__trunctfhf2(-3.1415926535, 0xc248);
+    test__trunctfhf2(0x1.987124876876324p+100, 0x7c00);
+    test__trunctfhf2(0x1.987124876876324p+12, 0x6e62);
+    test__trunctfhf2(0x1.0p+0, 0x3c00);
+    test__trunctfhf2(0x1.0p-14, 0x0400);
+    // denormal
+    test__trunctfhf2(0x1.0p-20, 0x0010);
+    test__trunctfhf2(0x1.0p-24, 0x0001);
+    test__trunctfhf2(-0x1.0p-24, 0x8001);
+    test__trunctfhf2(0x1.5p-25, 0x0001);
+    // and back to zero
+    test__trunctfhf2(0x1.0p-25, 0x0000);
+    test__trunctfhf2(-0x1.0p-25, 0x8000);
+    // max (precise)
+    test__trunctfhf2(65504.0, 0x7bff);
+    // max (rounded)
+    test__trunctfhf2(65519.0, 0x7bff);
+    // max (to +inf)
+    test__trunctfhf2(65520.0, 0x7c00);
+    test__trunctfhf2(65536.0, 0x7c00);
+    test__trunctfhf2(-65520.0, 0xfc00);
+
+    test__trunctfhf2(0x1.23a2abb4a2ddee355f36789abcdep+5, 0x508f);
+    test__trunctfhf2(0x1.e3d3c45bd3abfd98b76a54cc321fp-9, 0x1b8f);
+    test__trunctfhf2(0x1.234eebb5faa678f4488693abcdefp+453, 0x7c00);
+    test__trunctfhf2(0x1.edcba9bb8c76a5a43dd21f334634p-43, 0x0);
+}
+
+test "trunctfxf2" {
+    try test__trunctfxf2(1.5, 1.5);
+    try test__trunctfxf2(2.5, 2.5);
+    try test__trunctfxf2(-2.5, -2.5);
+    try test__trunctfxf2(0.0, 0.0);
+}
+
+fn test__trunctfxf2(a: f128, expected: f80) !void {
+    const x = __trunctfxf2(a);
+    try testing.expect(x == expected);
+}
diff --git a/lib/compiler_rt/truncsfhf2.zig b/lib/compiler_rt/truncsfhf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..5fe0f329b66bfe3fedcbd54fb9e11125009ecf0d
--- /dev/null
+++ b/lib/compiler_rt/truncsfhf2.zig
@@ -0,0 +1,26 @@
+const common = @import("./common.zig");
+const truncf = @import("./truncf.zig").truncf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_gnu_abi) {
+        @export(__gnu_f2h_ieee, .{ .name = "__gnu_f2h_ieee", .linkage = common.linkage });
+    } else if (common.want_aeabi) {
+        @export(__aeabi_f2h, .{ .name = "__aeabi_f2h", .linkage = common.linkage });
+    } else {
+        @export(__truncsfhf2, .{ .name = "__truncsfhf2", .linkage = common.linkage });
+    }
+}
+
+fn __truncsfhf2(a: f32) callconv(.C) common.F16T {
+    return @bitCast(common.F16T, truncf(f16, f32, a));
+}
+
+fn __gnu_f2h_ieee(a: f32) callconv(.C) common.F16T {
+    return @bitCast(common.F16T, truncf(f16, f32, a));
+}
+
+fn __aeabi_f2h(a: f32) callconv(.AAPCS) u16 {
+    return @bitCast(common.F16T, truncf(f16, f32, a));
+}
diff --git a/lib/compiler_rt/trunctfdf2.zig b/lib/compiler_rt/trunctfdf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..012de610c358623c25dbb632db45b558bdceb8c0
--- /dev/null
+++ b/lib/compiler_rt/trunctfdf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const truncf = @import("./truncf.zig").truncf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__trunckfdf2, .{ .name = "__trunckfdf2", .linkage = common.linkage });
+    } else {
+        @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = common.linkage });
+    }
+}
+
+fn __trunctfdf2(a: f128) callconv(.C) f64 {
+    return truncf(f64, f128, a);
+}
+
+fn __trunckfdf2(a: f128) callconv(.C) f64 {
+    return truncf(f64, f128, a);
+}
diff --git a/lib/compiler_rt/trunctfhf2.zig b/lib/compiler_rt/trunctfhf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a81cc138f1cf9db85d884ce727b89a43e81a7bbd
--- /dev/null
+++ b/lib/compiler_rt/trunctfhf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const truncf = @import("./truncf.zig").truncf;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__trunctfhf2, .{ .name = "__trunctfhf2", .linkage = common.linkage });
+}
+
+fn __trunctfhf2(a: f128) callconv(.C) common.F16T {
+    return @bitCast(common.F16T, truncf(f16, f128, a));
+}
diff --git a/lib/compiler_rt/trunctfsf2.zig b/lib/compiler_rt/trunctfsf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..535f73e47390d7fcaf967b5aec9a27a8c168a5c3
--- /dev/null
+++ b/lib/compiler_rt/trunctfsf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const truncf = @import("./truncf.zig").truncf;
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__trunckfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage });
+    } else {
+        @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage });
+    }
+}
+
+fn __trunctfsf2(a: f128) callconv(.C) f32 {
+    return truncf(f32, f128, a);
+}
+
+fn __trunckfsf2(a: f128) callconv(.C) f32 {
+    return truncf(f32, f128, a);
+}
diff --git a/lib/compiler_rt/trunctfxf2.zig b/lib/compiler_rt/trunctfxf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..0cb7f86a1fac0669e07df6f0ece3195ef038784c
--- /dev/null
+++ b/lib/compiler_rt/trunctfxf2.zig
@@ -0,0 +1,66 @@
+const math = @import("std").math;
+const common = @import("./common.zig");
+const trunc_f80 = @import("./truncf.zig").trunc_f80;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__trunctfxf2, .{ .name = "__trunctfxf2", .linkage = common.linkage });
+}
+
+fn __trunctfxf2(a: f128) callconv(.C) f80 {
+    const src_sig_bits = math.floatMantissaBits(f128);
+    const dst_sig_bits = math.floatMantissaBits(f80) - 1; // -1 for the integer bit
+
+    // Various constants whose values follow from the type parameters.
+    // Any reasonable optimizer will fold and propagate all of these.
+    const src_bits = @typeInfo(f128).Float.bits;
+    const src_exp_bits = src_bits - src_sig_bits - 1;
+    const src_inf_exp = 0x7FFF;
+
+    const src_inf = src_inf_exp << src_sig_bits;
+    const src_sign_mask = 1 << (src_sig_bits + src_exp_bits);
+    const src_abs_mask = src_sign_mask - 1;
+    const round_mask = (1 << (src_sig_bits - dst_sig_bits)) - 1;
+    const halfway = 1 << (src_sig_bits - dst_sig_bits - 1);
+
+    // Break a into a sign and representation of the absolute value
+    const a_rep = @bitCast(u128, a);
+    const a_abs = a_rep & src_abs_mask;
+    const sign: u16 = if (a_rep & src_sign_mask != 0) 0x8000 else 0;
+    const integer_bit = 1 << 63;
+
+    var res: math.F80 = undefined;
+
+    if (a_abs > src_inf) {
+        // a is NaN.
+        // Conjure the result by beginning with infinity, setting the qNaN
+        // bit and inserting the (truncated) trailing NaN field.
+        res.exp = 0x7fff;
+        res.fraction = 0x8000000000000000;
+        res.fraction |= @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits));
+    } else {
+        // The exponent of a is within the range of normal numbers in the
+        // destination format.  We can convert by simply right-shifting with
+        // rounding, adding the explicit integer bit, and adjusting the exponent
+        res.fraction = @truncate(u64, a_abs >> (src_sig_bits - dst_sig_bits)) | integer_bit;
+        res.exp = @truncate(u16, a_abs >> src_sig_bits);
+
+        const round_bits = a_abs & round_mask;
+        if (round_bits > halfway) {
+            // Round to nearest
+            const carry = @boolToInt(@addWithOverflow(u64, res.fraction, 1, &res.fraction));
+            res.exp += carry;
+            res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry
+        } else if (round_bits == halfway) {
+            // Ties to even
+            const carry = @boolToInt(@addWithOverflow(u64, res.fraction, res.fraction & 1, &res.fraction));
+            res.exp += carry;
+            res.fraction |= @as(u64, carry) << 63; // Restore integer bit after carry
+        }
+        if (res.exp == 0) res.fraction &= ~@as(u64, integer_bit); // Remove integer bit for de-normals
+    }
+
+    res.exp |= sign;
+    return math.make_f80(res);
+}
diff --git a/lib/compiler_rt/truncxfdf2.zig b/lib/compiler_rt/truncxfdf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..2b8eaaab8c291dfb847bedb54fc4744010a39742
--- /dev/null
+++ b/lib/compiler_rt/truncxfdf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const trunc_f80 = @import("./truncf.zig").trunc_f80;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__truncxfdf2, .{ .name = "__truncxfdf2", .linkage = common.linkage });
+}
+
+fn __truncxfdf2(a: f80) callconv(.C) f64 {
+    return trunc_f80(f64, a);
+}
diff --git a/lib/compiler_rt/truncxfhf2.zig b/lib/compiler_rt/truncxfhf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..75fdd178412ecae535e74cc9dccb376030ff407f
--- /dev/null
+++ b/lib/compiler_rt/truncxfhf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const trunc_f80 = @import("./truncf.zig").trunc_f80;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__truncxfhf2, .{ .name = "__truncxfhf2", .linkage = common.linkage });
+}
+
+fn __truncxfhf2(a: f80) callconv(.C) common.F16T {
+    return @bitCast(common.F16T, trunc_f80(f16, a));
+}
diff --git a/lib/compiler_rt/truncxfsf2.zig b/lib/compiler_rt/truncxfsf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..57c0cb7bdf78c50bc70467011592e18ae890bc72
--- /dev/null
+++ b/lib/compiler_rt/truncxfsf2.zig
@@ -0,0 +1,12 @@
+const common = @import("./common.zig");
+const trunc_f80 = @import("./truncf.zig").trunc_f80;
+
+pub const panic = common.panic;
+
+comptime {
+    @export(__truncxfsf2, .{ .name = "__truncxfsf2", .linkage = common.linkage });
+}
+
+fn __truncxfsf2(a: f80) callconv(.C) f32 {
+    return trunc_f80(f32, a);
+}
diff --git a/lib/compiler_rt/unorddf2.zig b/lib/compiler_rt/unorddf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..a6538f99d5b8c72ea99434e8cbac9abb452fd27c
--- /dev/null
+++ b/lib/compiler_rt/unorddf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = common.linkage });
+    } else {
+        @export(__unorddf2, .{ .name = "__unorddf2", .linkage = common.linkage });
+    }
+}
+
+fn __unorddf2(a: f64, b: f64) callconv(.C) i32 {
+    return comparef.unordcmp(f64, a, b);
+}
+
+fn __aeabi_dcmpun(a: f64, b: f64) callconv(.AAPCS) i32 {
+    return comparef.unordcmp(f64, a, b);
+}
diff --git a/lib/compiler_rt/unordsf2.zig b/lib/compiler_rt/unordsf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..1dc7eb178e0b86cd7bfa4c3007b1e32e3ebb5a45
--- /dev/null
+++ b/lib/compiler_rt/unordsf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_aeabi) {
+        @export(__aeabi_fcmpun, .{ .name = "__aeabi_fcmpun", .linkage = common.linkage });
+    } else {
+        @export(__unordsf2, .{ .name = "__unordsf2", .linkage = common.linkage });
+    }
+}
+
+fn __unordsf2(a: f32, b: f32) callconv(.C) i32 {
+    return comparef.unordcmp(f32, a, b);
+}
+
+fn __aeabi_fcmpun(a: f32, b: f32) callconv(.AAPCS) i32 {
+    return comparef.unordcmp(f32, a, b);
+}
diff --git a/lib/compiler_rt/unordtf2.zig b/lib/compiler_rt/unordtf2.zig
new file mode 100644
index 0000000000000000000000000000000000000000..833d6d6cee30551114fff9432024e764d7275bce
--- /dev/null
+++ b/lib/compiler_rt/unordtf2.zig
@@ -0,0 +1,20 @@
+const common = @import("./common.zig");
+const comparef = @import("./comparef.zig");
+
+pub const panic = common.panic;
+
+comptime {
+    if (common.want_ppc_abi) {
+        @export(__unordkf2, .{ .name = "__unordkf2", .linkage = common.linkage });
+    } else {
+        @export(__unordtf2, .{ .name = "__unordtf2", .linkage = common.linkage });
+    }
+}
+
+fn __unordtf2(a: f128, b: f128) callconv(.C) i32 {
+    return comparef.unordcmp(f128, a, b);
+}
+
+fn __unordkf2(a: f128, b: f128) callconv(.C) i32 {
+    return comparef.unordcmp(f128, a, b);
+}
diff --git a/src/compiler_rt.zig b/src/compiler_rt.zig
index 5149ce192fe54ecf954ef6460ead0b0eab69afd7..3418886a424ddd4d234c2092084d9a1f8dceb1d0 100644
--- a/src/compiler_rt.zig
+++ b/src/compiler_rt.zig
@@ -200,8 +200,8 @@ const sources = &[_][]const u8{
     "compiler_rt/umodti3.zig",
     "compiler_rt/truncXfYf2.zig",
     "compiler_rt/trunc_f80.zig",
-    "compiler_rt/addXf3.zig",
-    "compiler_rt/mulXf3.zig",
+    "compiler_rt/addf3.zig",
+    "compiler_rt/mulf3.zig",
     "compiler_rt/divsf3.zig",
     "compiler_rt/divdf3.zig",
     "compiler_rt/divxf3.zig",