float: Use a fallback for f16 float format/parse if needed

In order to avoid crashes when compiling with Cranelift or on targets
where f16 is not well supported, choose to use a fallback based on
`target_has_reliable_f16`.

Author: tgross35

library/core/Cargo.toml

@@ -36,4 +36,6 @@ check-cfg = [
     # and to stdarch `core_arch` crate which messes-up with Cargo list
     # of declared features, we therefor expect any feature cfg
     'cfg(feature, values(any()))',
+    # Internal features aren't marked known config by default
+    'cfg(target_has_reliable_f16)',
 ]

library/core/src/fmt/float.rs

@@ -230,7 +230,63 @@ macro_rules! floating {
     };
 }
 
-floating! { f16 f32 f64 }
+floating! { f32 f64 }
+
+#[cfg(bootstrap)]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Debug for f16 {
+    #[inline]
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "{:#06x}", self.to_bits())
+    }
+}
+
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16)]
+floating! { f16 }
+
+// FIXME(f16_f128): A fallback is used when the backend+target does not support f16 well, in order
+// to avoid ICEs.
+
+#[cfg(not(bootstrap))]
+#[cfg(not(target_has_reliable_f16))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Debug for f16 {
+    #[inline]
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(f, "{:#06x}", self.to_bits())
+    }
+}
+
+#[cfg(not(bootstrap))]
+#[cfg(not(target_has_reliable_f16))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Display for f16 {
+    #[inline]
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+        Debug::fmt(self, fmt)
+    }
+}
+
+#[cfg(not(bootstrap))]
+#[cfg(not(target_has_reliable_f16))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl LowerExp for f16 {
+    #[inline]
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+        Debug::fmt(self, fmt)
+    }
+}
+
+#[cfg(not(bootstrap))]
+#[cfg(not(target_has_reliable_f16))]
+#[stable(feature = "rust1", since = "1.0.0")]
+impl UpperExp for f16 {
+    #[inline]
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+        Debug::fmt(self, fmt)
+    }
+}
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Debug for f128 {

library/core/src/lib.rs

@@ -95,6 +95,7 @@
 //
 // Library features:
 // tidy-alphabetical-start
+#![cfg_attr(not(bootstrap), feature(cfg_target_has_reliable_f16_f128))]
 #![feature(array_ptr_get)]
 #![feature(asm_experimental_arch)]
 #![feature(bigint_helper_methods)]

library/core/src/num/dec2flt/float.rs

@@ -218,6 +218,8 @@ const fn pow2_to_pow10(a: i64) -> i64 {
     res as i64
 }
 
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16)]
 impl RawFloat for f16 {
     type Int = u16;
 

library/core/src/num/dec2flt/mod.rs

@@ -172,10 +172,26 @@ macro_rules! from_str_float_impl {
     };
 }
 
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16)]
 from_str_float_impl!(f16);
 from_str_float_impl!(f32);
 from_str_float_impl!(f64);
 
+// FIXME(f16_f128): A fallback is used when the backend+target does not support f16 well, in order
+// to avoid ICEs.
+
+// After the bootstrap bump this should be: `#[cfg(not(target_has_reliable_f16))`
+#[cfg(any(bootstrap, all(not(bootstrap), not(target_has_reliable_f16))))]
+impl FromStr for f16 {
+    type Err = ParseFloatError;
+
+    #[inline]
+    fn from_str(_src: &str) -> Result<Self, ParseFloatError> {
+        unimplemented!("requires target_has_reliable_f16")
+    }
+}
+
 /// An error which can be returned when parsing a float.
 ///
 /// This error is used as the error type for the [`FromStr`] implementation

library/core/src/num/flt2dec/decoder.rs

@@ -45,6 +45,8 @@ pub trait DecodableFloat: RawFloat + Copy {
     fn min_pos_norm_value() -> Self;
 }
 
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16)]
 impl DecodableFloat for f16 {
     fn min_pos_norm_value() -> Self {
         f16::MIN_POSITIVE

library/coretests/tests/num/dec2flt/mod.rs

@@ -11,6 +11,8 @@ mod parse;
 // Requires a *polymorphic literal*, i.e., one that can serve as f64 as well as f32.
 macro_rules! test_literal {
     ($x: expr) => {{
+        #[cfg(not(bootstrap))]
+        #[cfg(target_has_reliable_f16)]
         let x16: f16 = $x;
         let x32: f32 = $x;
         let x64: f64 = $x;
@@ -19,11 +21,15 @@ macro_rules! test_literal {
         for input in inputs {
             assert_eq!(input.parse(), Ok(x64), "failed f64 {input}");
             assert_eq!(input.parse(), Ok(x32), "failed f32 {input}");
+            #[cfg(not(bootstrap))]
+            #[cfg(target_has_reliable_f16)]
             assert_eq!(input.parse(), Ok(x16), "failed f16 {input}");
 
             let neg_input = format!("-{input}");
             assert_eq!(neg_input.parse(), Ok(-x64), "failed f64 {neg_input}");
             assert_eq!(neg_input.parse(), Ok(-x32), "failed f32 {neg_input}");
+            #[cfg(not(bootstrap))]
+            #[cfg(target_has_reliable_f16)]
             assert_eq!(neg_input.parse(), Ok(-x16), "failed f16 {neg_input}");
         }
     }};

library/coretests/tests/num/dec2flt/parse.rs

@@ -10,6 +10,8 @@ fn new_dec(e: i64, m: u64) -> Decimal {
 fn missing_pieces() {
     let permutations = &[".e", "1e", "e4", "e", ".12e", "321.e", "32.12e+", "12.32e-"];
     for &s in permutations {
+        #[cfg(not(bootstrap))]
+        #[cfg(target_has_reliable_f16)]
         assert_eq!(dec2flt::<f16>(s), Err(pfe_invalid()));
         assert_eq!(dec2flt::<f32>(s), Err(pfe_invalid()));
         assert_eq!(dec2flt::<f64>(s), Err(pfe_invalid()));
@@ -28,6 +30,8 @@ fn invalid_chars() {
                 input.push_str(s);
                 input.insert(i, c);
 
+                #[cfg(not(bootstrap))]
+                #[cfg(target_has_reliable_f16)]
                 assert_eq!(
                     dec2flt::<f16>(&input),
                     Err(pfe_invalid()),

src/etc/test-float-parse/Cargo.toml

@@ -13,3 +13,10 @@ rayon = "1"
 
 [lib]
 name = "test_float_parse"
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = [
+    # Internal features aren't marked known config by default
+    'cfg(target_has_reliable_f16)',
+]

src/etc/test-float-parse/src/lib.rs

@@ -1,4 +1,6 @@
 #![feature(f16)]
+#![feature(cfg_target_has_reliable_f16_f128)]
+#![expect(internal_features)] // reliable_f16_f128
 
 mod traits;
 mod ui;
@@ -116,6 +118,8 @@ pub fn register_tests(cfg: &Config) -> Vec<TestInfo> {
     let mut tests = Vec::new();
 
     // Register normal generators for all floats.
+
+    #[cfg(target_has_reliable_f16)]
     register_float::<f16>(&mut tests, cfg);
     register_float::<f32>(&mut tests, cfg);
     register_float::<f64>(&mut tests, cfg);

src/etc/test-float-parse/src/traits.rs

@@ -168,7 +168,10 @@ macro_rules! impl_float {
     }
 }
 
-impl_float!(f16, u16; f32, u32; f64, u64);
+impl_float!(f32, u32; f64, u64);
+
+#[cfg(target_has_reliable_f16)]
+impl_float!(f16, u16);
 
 /// A test generator. Should provide an iterator that produces unique patterns to parse.
 ///