mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #128349 - tgross35:x86-f16, r=Noratrieb

Browse Source 
Enable `f16` tests on x86 and x86-64

Since the `compiler_builtins` update [1], ABI bugs on x86 should be resolved. Enable tests for f16 on these platforms now.

`f16` math functions (`reliable_f16_math`) are still excluded because there is an LLVM crash for powi [2].

[1]: https://github.com/rust-lang/rust/pull/125016
[2]: https://github.com/llvm/llvm-project/issues/105747

try-job: dist-i586-gnu-i586-i686-musl
try-job: x86_64-apple-1
This commit is contained in:
bors 2024-08-24 13:03:04 +00:00
commit f167efad2f
2 changed files with 21 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
library/core/src/num/f16.rs
View File

@ -261,7 +261,7 @@ impl f16 {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let nan = f16::NAN; /// let nan = f16::NAN;
/// let f = 7.0_f16; /// let f = 7.0_f16;
@ -293,7 +293,7 @@ pub(crate) const fn abs_private(self) -> f16 {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let f = 7.0f16; /// let f = 7.0f16;
/// let inf = f16::INFINITY; /// let inf = f16::INFINITY;
@ -319,7 +319,7 @@ pub const fn is_infinite(self) -> bool {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let f = 7.0f16; /// let f = 7.0f16;
/// let inf: f16 = f16::INFINITY; /// let inf: f16 = f16::INFINITY;
@ -347,7 +347,7 @@ pub const fn is_finite(self) -> bool {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let min = f16::MIN_POSITIVE; // 6.1035e-5 /// let min = f16::MIN_POSITIVE; // 6.1035e-5
/// let max = f16::MAX; /// let max = f16::MAX;
@ -377,7 +377,7 @@ pub const fn is_subnormal(self) -> bool {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let min = f16::MIN_POSITIVE; // 6.1035e-5 /// let min = f16::MIN_POSITIVE; // 6.1035e-5
/// let max = f16::MAX; /// let max = f16::MAX;
@ -409,7 +409,7 @@ pub const fn is_normal(self) -> bool {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// use std::num::FpCategory; /// use std::num::FpCategory;
/// ///
@ -867,7 +867,7 @@ pub fn midpoint(self, other: f16) -> f16 {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let value = 4.6_f16; /// let value = 4.6_f16;
/// let rounded = unsafe { value.to_int_unchecked::<u16>() }; /// let rounded = unsafe { value.to_int_unchecked::<u16>() };
@ -910,7 +910,7 @@ pub unsafe fn to_int_unchecked<Int>(self) -> Int
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// # // FIXME(f16_f128): enable this once const casting works /// # // FIXME(f16_f128): enable this once const casting works
/// # // assert_ne!((1f16).to_bits(), 1f16 as u128); // to_bits() is not casting! /// # // assert_ne!((1f16).to_bits(), 1f16 as u128); // to_bits() is not casting!
@ -958,7 +958,7 @@ pub const fn to_bits(self) -> u16 {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let v = f16::from_bits(0x4a40); /// let v = f16::from_bits(0x4a40);
/// assert_eq!(v, 12.5); /// assert_eq!(v, 12.5);
@ -1071,7 +1071,7 @@ pub const fn from_bits(v: u16) -> Self {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let value = f16::from_be_bytes([0x4a, 0x40]); /// let value = f16::from_be_bytes([0x4a, 0x40]);
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
@ -1094,7 +1094,7 @@ pub const fn from_bits(v: u16) -> Self {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let value = f16::from_le_bytes([0x40, 0x4a]); /// let value = f16::from_le_bytes([0x40, 0x4a]);
/// assert_eq!(value, 12.5); /// assert_eq!(value, 12.5);
@ -1124,7 +1124,7 @@ pub const fn from_bits(v: u16) -> Self {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// let value = f16::from_ne_bytes(if cfg!(target_endian = "big") { /// let value = f16::from_ne_bytes(if cfg!(target_endian = "big") {
/// [0x4a, 0x40] /// [0x4a, 0x40]
@ -1257,7 +1257,7 @@ pub fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering {
/// ///
/// ``` /// ```
/// #![feature(f16)] /// #![feature(f16)]
/// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885 /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
/// ///
/// assert!((-3.0f16).clamp(-2.0, 1.0) == -2.0); /// assert!((-3.0f16).clamp(-2.0, 1.0) == -2.0);
/// assert!((0.0f16).clamp(-2.0, 1.0) == 0.0); /// assert!((0.0f16).clamp(-2.0, 1.0) == 0.0);

16
library/std/build.rs
View File

@ -103,9 +103,9 @@ fn main() {
("arm64ec", _) => false, ("arm64ec", _) => false,
// MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054> // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
("x86_64", "windows") => false, ("x86_64", "windows") => false,
// x86 has ABI bugs that show up with optimizations. This should be partially fixed with // Apple has a special ABI for `f16` that we do not yet support
// the compiler-builtins update. <https://github.com/rust-lang/rust/issues/123885> // FIXME(builtins): fixed by <https://github.com/rust-lang/compiler-builtins/pull/675>
("x86" | "x86_64", _) => false, ("x86" | "x86_64", _) if target_vendor == "apple" => false,
// Missing `__gnu_h2f_ieee` and `__gnu_f2h_ieee` // Missing `__gnu_h2f_ieee` and `__gnu_f2h_ieee`
("powerpc" | "powerpc64", _) => false, ("powerpc" | "powerpc64", _) => false,
// Missing `__gnu_h2f_ieee` and `__gnu_f2h_ieee` // Missing `__gnu_h2f_ieee` and `__gnu_f2h_ieee`
@ -140,17 +140,17 @@ fn main() {
_ => false, _ => false,
}; };
// These are currently empty, but will fill up as some platforms move from completely // Configure platforms that have reliable basics but may have unreliable math.
// unreliable to reliable basics but unreliable math.
// LLVM is currenlty adding missing routines, <https://github.com/llvm/llvm-project/issues/93566> // LLVM is currenlty adding missing routines, <https://github.com/llvm/llvm-project/issues/93566>
let has_reliable_f16_math = has_reliable_f16 let has_reliable_f16_math = has_reliable_f16
&& match (target_arch.as_str(), target_os.as_str()) { && match (target_arch.as_str(), target_os.as_str()) {
// FIXME: Disabled on Miri as the intrinsics are not implemented yet. // FIXME: Disabled on Miri as the intrinsics are not implemented yet.
_ if is_miri => false, _ if is_miri => false,
// Currently nothing special. Hooray! // x86 has a crash for `powi`: <https://github.com/llvm/llvm-project/issues/105747>
// This will change as platforms gain better better support for standard ops but math ("x86" | "x86_64", _) => false,
// lags behind. // Assume that working `f16` means working `f16` math for most platforms, since
// operations just go through `f32`.
_ => true, _ => true,
}; };