Use a fallback for f16 float format/parse if the type is unreliable

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,59 @@ 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())
+    }
+}
+
+// On target
+
+#[cfg(not(bootstrap))]
+#[cfg(target_has_reliable_f16)]
+floating! { f16 }
+
+#[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 {
+    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 {
+    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 {
+    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(not(target_has_reliable_f16))]
 impl RawFloat for f16 {
     type Int = u16;
 

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

@@ -172,10 +172,22 @@ 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);
 
+#[cfg(not(bootstrap))]
+#[cfg(not(target_has_reliable_f16))]
+impl FromStr for f16 {
+    type Err = ParseFloatError;
+
+    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(not(target_has_reliable_f16))]
 impl DecodableFloat for f16 {
     fn min_pos_norm_value() -> Self {
         f16::MIN_POSITIVE