Add integer to f16 conversions

These are not present in LLVM's `compiler-rt` but LLVM does emit them in
some cases [1].

[1]: rust-lang/rust#132614 (comment)

Author: tgross35

builtins-test/Cargo.toml

@@ -35,9 +35,10 @@ no-asm = ["compiler_builtins/no-asm"]
 mem = ["compiler_builtins/mem"]
 mangled-names = ["compiler_builtins/mangled-names"]
 # Skip tests that rely on f128 symbols being available on the system
-no-sys-f128 = ["no-sys-f128-int-convert", "no-sys-f16-f128-convert"]
+no-sys-f128 = ["no-sys-f16-int-convert", "no-sys-f128-int-convert", "no-sys-f16-f128-convert"]
 # Some platforms have some f128 functions but everything except integer conversions
 no-sys-f128-int-convert = []
+no-sys-f16-int-convert = []
 no-sys-f16-f128-convert = []
 no-sys-f16-f64-convert = []
 # Skip tests that rely on f16 symbols being available on the system

builtins-test/build.rs

@@ -11,6 +11,7 @@ enum Feature {
     NoSysF128IntConvert,
     NoSysF16,
     NoSysF16F64Convert,
+    NoSysF16IntConvert,
     NoSysF16F128Convert,
 }
 
@@ -19,7 +20,13 @@ impl Feature {
         match self {
             Self::NoSysF128 => [Self::NoSysF128IntConvert, Self::NoSysF16F128Convert].as_slice(),
             Self::NoSysF128IntConvert => [].as_slice(),
-            Self::NoSysF16 => [Self::NoSysF16F64Convert, Self::NoSysF16F128Convert].as_slice(),
+            Self::NoSysF16 => [
+                Self::NoSysF16IntConvert,
+                Self::NoSysF16F64Convert,
+                Self::NoSysF16F128Convert,
+            ]
+            .as_slice(),
+            Self::NoSysF16IntConvert => [].as_slice(),
             Self::NoSysF16F64Convert => [].as_slice(),
             Self::NoSysF16F128Convert => [].as_slice(),
         }
@@ -101,6 +108,10 @@ fn main() {
                 "no-sys-f128-int-convert",
                 "using apfloat fallback for f128 <-> int conversions",
             ),
+            Feature::NoSysF16IntConvert => (
+                "no-sys-f16-int-convert",
+                "using apfloat fallback for f16 <-> int conversions",
+            ),
             Feature::NoSysF16F64Convert => (
                 "no-sys-f16-f64-convert",
                 "using apfloat fallback for f16 <-> f64 conversions",

builtins-test/tests/conv.rs

@@ -34,7 +34,7 @@ mod i_to_f {
                                     FloatTy::from_u128(x.try_into().unwrap()).value
                                 };
 
-                                <$f_ty>::from_bits(apf.to_bits())
+                                <$f_ty>::from_bits(apf.to_bits().try_into().unwrap())
                             },
                             x
                         );
@@ -96,6 +96,16 @@ mod i_to_f {
         };
     }
 
+    #[cfg(f16_enabled)]
+    i_to_f! { f16, Half, not(feature = "no-sys-f16-int-convert"),
+        u32, __floatunsihf;
+        i32, __floatsihf;
+        u64, __floatundihf;
+        i64, __floatdihf;
+        u128, __floatuntihf;
+        i128, __floattihf;
+    }
+
     i_to_f! { f32, Single, all(),
         u32, __floatunsisf;
         i32, __floatsisf;

compiler-builtins/README.md

@@ -159,11 +159,17 @@ of being added to Rust.
 - [x] fixunstfdi.c
 - [x] fixunstfsi.c
 - [x] fixunstfti.c
+- [x] floatdihf.c (not yet in `compiler-rt` but emitted by LLVM)
 - [x] floatditf.c
+- [x] floatsihf.c (not yet in `compiler-rt` but emitted by LLVM)
 - [x] floatsitf.c
+- [x] floattihf.c (not yet in `compiler-rt` but emitted by LLVM)
 - [x] floattitf.c
+- [x] floatundihf.c (not yet in `compiler-rt` but emitted by LLVM)
 - [x] floatunditf.c
+- [x] floatunsihf.c (not yet in `compiler-rt` but emitted by LLVM)
 - [x] floatunsitf.c
+- [x] floatuntihf.c (not yet in `compiler-rt` but emitted by LLVM)
 - [x] floatuntitf.c
 - [x] multf3.c
 - [x] powitf2.c

compiler-builtins/src/float/conv.rs

@@ -78,6 +78,26 @@ mod int_to_float {
         F::from_bits(conv(i.unsigned_abs()) | sign_bit)
     }
 
+    #[cfg(f16_enabled)]
+    pub fn u32_to_f16_bits(i: u32) -> u16 {
+        let n = i.leading_zeros();
+        let i_m = i.wrapping_shl(n);
+        // Mantissa with implicit bit set
+        let m_base: u16 = (i_m >> shift_f_lt_i::<u32, f16>()) as u16;
+        // The entire lower half of `i` will be truncated (masked portion), plus the
+        // next `EXP_BITS` bits.
+        let adj = (i_m >> f16::EXP_BITS | i_m & 0xFF) as u16;
+        let m = m_adj::<f16>(m_base, adj);
+        let e = if i == 0 { 0 } else { exp::<u32, f16>(n) - 1 };
+        // Any int can have an exponent out of range for `f16`, unlike other float types.
+        // Clamp this.
+        if e >= f16::EXP_SAT as u16 - 1 {
+            f16::INFINITY.to_bits()
+        } else {
+            repr::<f16>(e, m)
+        }
+    }
+
     pub fn u32_to_f32_bits(i: u32) -> u32 {
         if i == 0 {
             return 0;
@@ -121,6 +141,33 @@ mod int_to_float {
         (h as u128) << 64
     }
 
+    #[cfg(f16_enabled)]
+    pub fn u64_to_f16_bits(i: u64) -> u16 {
+        let n = i.leading_zeros();
+        let i_m = i.wrapping_shl(n); // Mantissa, shifted so the first bit is nonzero
+        let m_base: u16 = (i_m >> shift_f_lt_i::<u64, f16>()) as u16;
+
+        // Within the upper `F::BITS`, everything except for the signifcand
+        // gets truncated
+        let d1: u16 = (i_m >> (u64::BITS - f16::BITS - f16::SIG_BITS - 1)).cast();
+
+        // The entire rest of `i_m` gets truncated. Zero the upper `F::BITS` then just
+        // check if it is nonzero.
+        let d2: u16 = (i_m << f16::BITS >> f16::BITS != 0).into();
+        let adj = d1 | d2;
+
+        // Mantissa with implicit bit set
+        let m = m_adj::<f16>(m_base, adj);
+        let e = if i == 0 { 0 } else { exp::<u64, f16>(n) - 1 };
+
+        // Clamp to infinity if the exponent is out of range
+        if e >= f16::EXP_SAT as u16 - 1 {
+            f16::INFINITY.to_bits()
+        } else {
+            repr::<f16>(e, m)
+        }
+    }
+
     pub fn u64_to_f32_bits(i: u64) -> u32 {
         let n = i.leading_zeros();
         let i_m = i.wrapping_shl(n);
@@ -159,6 +206,33 @@ mod int_to_float {
         repr::<f128>(e, m)
     }
 
+    #[cfg(f16_enabled)]
+    pub fn u128_to_f16_bits(i: u128) -> u16 {
+        let n = i.leading_zeros();
+        let i_m = i.wrapping_shl(n); // Mantissa, shifted so the first bit is nonzero
+        let m_base: u16 = (i_m >> shift_f_lt_i::<u128, f16>()) as u16;
+
+        // Within the upper `F::BITS`, everything except for the signifcand
+        // gets truncated
+        let d1: u16 = (i_m >> (u128::BITS - f16::BITS - f16::SIG_BITS - 1)).cast();
+
+        // The entire rest of `i_m` gets truncated. Zero the upper `F::BITS` then just
+        // check if it is nonzero.
+        let d2: u16 = (i_m << f16::BITS >> f16::BITS != 0).into();
+        let adj = d1 | d2;
+
+        // Mantissa with implicit bit set
+        let m = m_adj::<f16>(m_base, adj);
+        let e = if i == 0 { 0 } else { exp::<u128, f16>(n) - 1 };
+
+        // Clamp to infinity if the exponent is out of range
+        if e >= f16::EXP_SAT as u16 - 1 {
+            f16::INFINITY.to_bits()
+        } else {
+            repr::<f16>(e, m)
+        }
+    }
+
     pub fn u128_to_f32_bits(i: u128) -> u32 {
         let n = i.leading_zeros();
         let i_m = i.wrapping_shl(n); // Mantissa, shifted so the first bit is nonzero
@@ -209,6 +283,11 @@ mod int_to_float {
 
 // Conversions from unsigned integers to floats.
 intrinsics! {
+    #[cfg(f16_enabled)]
+    pub extern "C" fn __floatunsihf(i: u32) -> f16 {
+        f16::from_bits(int_to_float::u32_to_f16_bits(i))
+    }
+
     #[arm_aeabi_alias = __aeabi_ui2f]
     pub extern "C" fn __floatunsisf(i: u32) -> f32 {
         f32::from_bits(int_to_float::u32_to_f32_bits(i))
@@ -219,6 +298,17 @@ intrinsics! {
         f64::from_bits(int_to_float::u32_to_f64_bits(i))
     }
 
+    #[ppc_alias = __floatunsikf]
+    #[cfg(f128_enabled)]
+    pub extern "C" fn __floatunsitf(i: u32) -> f128 {
+        f128::from_bits(int_to_float::u32_to_f128_bits(i))
+    }
+
+    #[cfg(f16_enabled)]
+    pub extern "C" fn __floatundihf(i: u64) -> f16 {
+        f16::from_bits(int_to_float::u64_to_f16_bits(i))
+    }
+
     #[arm_aeabi_alias = __aeabi_ul2f]
     pub extern "C" fn __floatundisf(i: u64) -> f32 {
         f32::from_bits(int_to_float::u64_to_f32_bits(i))
@@ -229,6 +319,17 @@ intrinsics! {
         f64::from_bits(int_to_float::u64_to_f64_bits(i))
     }
 
+    #[ppc_alias = __floatundikf]
+    #[cfg(f128_enabled)]
+    pub extern "C" fn __floatunditf(i: u64) -> f128 {
+        f128::from_bits(int_to_float::u64_to_f128_bits(i))
+    }
+
+    #[cfg(f16_enabled)]
+    pub extern "C" fn __floatuntihf(i: u128) -> f16 {
+        f16::from_bits(int_to_float::u128_to_f16_bits(i))
+    }
+
     #[cfg_attr(target_os = "uefi", unadjusted_on_win64)]
     pub extern "C" fn __floatuntisf(i: u128) -> f32 {
         f32::from_bits(int_to_float::u128_to_f32_bits(i))
@@ -239,18 +340,6 @@ intrinsics! {
         f64::from_bits(int_to_float::u128_to_f64_bits(i))
     }
 
-    #[ppc_alias = __floatunsikf]
-    #[cfg(f128_enabled)]
-    pub extern "C" fn __floatunsitf(i: u32) -> f128 {
-        f128::from_bits(int_to_float::u32_to_f128_bits(i))
-    }
-
-    #[ppc_alias = __floatundikf]
-    #[cfg(f128_enabled)]
-    pub extern "C" fn __floatunditf(i: u64) -> f128 {
-        f128::from_bits(int_to_float::u64_to_f128_bits(i))
-    }
-
     #[ppc_alias = __floatuntikf]
     #[cfg(f128_enabled)]
     pub extern "C" fn __floatuntitf(i: u128) -> f128 {
@@ -260,6 +349,11 @@ intrinsics! {
 
 // Conversions from signed integers to floats.
 intrinsics! {
+    #[cfg(f16_enabled)]
+    pub extern "C" fn __floatsihf(i: i32) -> f16 {
+        int_to_float::signed(i, int_to_float::u32_to_f16_bits)
+    }
+
     #[arm_aeabi_alias = __aeabi_i2f]
     pub extern "C" fn __floatsisf(i: i32) -> f32 {
         int_to_float::signed(i, int_to_float::u32_to_f32_bits)
@@ -270,6 +364,17 @@ intrinsics! {
         int_to_float::signed(i, int_to_float::u32_to_f64_bits)
     }
 
+    #[ppc_alias = __floatsikf]
+    #[cfg(f128_enabled)]
+    pub extern "C" fn __floatsitf(i: i32) -> f128 {
+        int_to_float::signed(i, int_to_float::u32_to_f128_bits)
+    }
+
+    #[cfg(f16_enabled)]
+    pub extern "C" fn __floatdihf(i: i64) -> f16 {
+        int_to_float::signed(i, int_to_float::u64_to_f16_bits)
+    }
+
     #[arm_aeabi_alias = __aeabi_l2f]
     pub extern "C" fn __floatdisf(i: i64) -> f32 {
         int_to_float::signed(i, int_to_float::u64_to_f32_bits)
@@ -280,6 +385,17 @@ intrinsics! {
         int_to_float::signed(i, int_to_float::u64_to_f64_bits)
     }
 
+    #[ppc_alias = __floatdikf]
+    #[cfg(f128_enabled)]
+    pub extern "C" fn __floatditf(i: i64) -> f128 {
+        int_to_float::signed(i, int_to_float::u64_to_f128_bits)
+    }
+
+    #[cfg(f16_enabled)]
+    pub extern "C" fn __floattihf(i: i128) -> f16 {
+        int_to_float::signed(i, int_to_float::u128_to_f16_bits)
+    }
+
     #[cfg_attr(target_os = "uefi", unadjusted_on_win64)]
     pub extern "C" fn __floattisf(i: i128) -> f32 {
         int_to_float::signed(i, int_to_float::u128_to_f32_bits)
@@ -290,18 +406,6 @@ intrinsics! {
         int_to_float::signed(i, int_to_float::u128_to_f64_bits)
     }
 
-    #[ppc_alias = __floatsikf]
-    #[cfg(f128_enabled)]
-    pub extern "C" fn __floatsitf(i: i32) -> f128 {
-        int_to_float::signed(i, int_to_float::u32_to_f128_bits)
-    }
-
-    #[ppc_alias = __floatdikf]
-    #[cfg(f128_enabled)]
-    pub extern "C" fn __floatditf(i: i64) -> f128 {
-        int_to_float::signed(i, int_to_float::u64_to_f128_bits)
-    }
-
     #[ppc_alias = __floattikf]
     #[cfg(f128_enabled)]
     pub extern "C" fn __floattitf(i: i128) -> f128 {