Commit c99c085d70

@@ -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");

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -1,111 +1,12 @@
-// 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 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 {
+/// 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));
@@ -267,5 +168,5 @@ pub fn addXf3(comptime T: type, a: T, b: T) T {
 }
 
 test {
-    _ = @import("addXf3_test.zig");
+    _ = @import("addf3_test.zig");
 }

@@ -7,7 +7,7 @@ const std = @import("std");
 const math = std.math;
 const qnan128 = @bitCast(f128, @as(u128, 0x7fff800000000000) << 64);
 
-const __addtf3 = @import("addXf3.zig").__addtf3;
+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);
@@ -48,7 +48,7 @@ test "addtf3" {
     try test__addtf3(0x1.edcba52449872455634654321fp-1, 0x1.23456734245345543849abcdefp+5, 0x40042afc95c8b579, 0x61e58dd6c51eb77c);
 }
 
-const __subtf3 = @import("addXf3.zig").__subtf3;
+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);
@@ -87,7 +87,7 @@ test "subtf3" {
     try test__subtf3(0x1.ee9d7c52354a6936ab8d7654321fp-1, 0x1.234567829a3bcdef5678ade36734p+5, 0xc0041b8af1915166, 0xa44a7bca780a166c);
 }
 
-const __addxf3 = @import("addXf3.zig").__addxf3;
+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 {

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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;
 }

@@ -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");
+}

@@ -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");
-}

@@ -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);
-}

@@ -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));
+}

@@ -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));
+}

@@ -1,81 +1,10 @@
 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);
 
+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);
@@ -143,6 +72,71 @@ inline fn extendXfYf2(comptime dst_t: type, comptime src_t: type, a: std.meta.In
     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");
 }

@@ -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));
+}

@@ -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));
+}

@@ -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));
+}

@@ -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));
+}

@@ -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));
+}

@@ -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));
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}

@@ -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);
+}