interpret: test SNaN handling of float min/max and update comments

Author: RalfJung

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -40,17 +40,19 @@ pub(crate) enum MinMax {
     /// In particular, `-0.0` is considered smaller than `+0.0` and
     /// if either input is NaN, the result is NaN.
     Minimum,
-    /// The IEEE-2008 `minNum` operation - see `f32::min` etc.
+    /// The IEEE-2008 `minNum` operation with the SNaN handling of the
+    /// IEEE-2019 `minimumNumber` operation - see `f32::min` etc.
     /// In particular, if the inputs are `-0.0` and `+0.0`, the result is non-deterministic,
-    /// and if one argument is NaN, the other one is returned.
+    /// and if one argument is NaN (quiet or signaling), the other one is returned.
     MinNum,
     /// The IEEE-2019 `maximum` operation - see `f32::maximum` etc.
     /// In particular, `-0.0` is considered smaller than `+0.0` and
     /// if either input is NaN, the result is NaN.
     Maximum,
-    /// The IEEE-2008 `maxNum` operation - see `f32::max` etc.
+    /// The IEEE-2008 `maxNum` operation with the SNaN handling of the
+    /// IEEE-2019 `maximumNumber` operation - see `f32::max` etc.
     /// In particular, if the inputs are `-0.0` and `+0.0`, the result is non-deterministic,
-    /// and if one argument is NaN, the other one is returned.
+    /// and if one argument is NaN (quiet or signaling), the other one is returned.
     MaxNum,
 }
 

src/tools/miri/tests/pass/float.rs

@@ -48,29 +48,14 @@ macro_rules! assert_approx_eq {
     };
 }
 
-/// From IEEE 754 a Signaling NaN for single precision has the following representation:
-/// ```
-/// s | 1111 1111 | 0x..x
-/// ````
-/// Were at least one `x` is a 1.
-///
-/// This sNaN has the following representation and is used for testing purposes.:
-/// ```
-/// 0 | 1111111 | 01..0
-/// ```
-const SNAN_F32: f32 = f32::from_bits(0x7fa00000);
-
-/// From IEEE 754 a Signaling NaN for double precision has the following representation:
-/// ```
-/// s | 1111 1111 111 | 0x..x
-/// ````
-/// Were at least one `x` is a 1.
-///
-/// This sNaN has the following representation and is used for testing purposes.:
-/// ```
-/// 0 | 1111 1111 111 | 01..0
-/// ```
-const SNAN_F64: f64 = f64::from_bits(0x7ff4000000000000);
+/// We turn the quiet NaN f*::NAN into a signaling one by flipping the first (most significant)
+/// two bits of the mantissa. For this we have to shift by `MANTISSA_DIGITS-3` because:
+/// we subtract 1 as the actual mantissa is 1 bit smaller, and 2 more as that's the width
+/// if the value we are shifting.
+const F16_SNAN: f16 =f16::from_bits(f16::NAN.to_bits() ^ (0b11 << (f16::MANTISSA_DIGITS-3)));
+const F32_SNAN: f32 =f32::from_bits(f32::NAN.to_bits() ^ (0b11 << (f32::MANTISSA_DIGITS-3)));
+const F64_SNAN: f64 =f64::from_bits(f64::NAN.to_bits() ^ (0b11 << (f64::MANTISSA_DIGITS-3)));
+const F128_SNAN: f128 =f128::from_bits(f128::NAN.to_bits() ^ (0b11 << (f128::MANTISSA_DIGITS-3)));
 
 fn main() {
     basic();
@@ -757,6 +742,8 @@ fn ops() {
     assert_eq(f16::NAN.max(-9.0), -9.0);
     assert_eq((9.0_f16).min(f16::NAN), 9.0);
     assert_eq((-9.0_f16).max(f16::NAN), -9.0);
+    assert_eq(F16_SNAN.min(9.0), 9.0);
+    assert_eq((-9.0_f16).max(F16_SNAN), -9.0);
 
     // f32 min/max
     assert_eq((1.0 as f32).max(-1.0), 1.0);
@@ -765,6 +752,8 @@ fn ops() {
     assert_eq(f32::NAN.max(-9.0), -9.0);
     assert_eq((9.0 as f32).min(f32::NAN), 9.0);
     assert_eq((-9.0 as f32).max(f32::NAN), -9.0);
+    assert_eq(F32_SNAN.min(9.0), 9.0);
+    assert_eq((-9.0_f32).max(F32_SNAN), -9.0);
 
     // f64 min/max
     assert_eq((1.0 as f64).max(-1.0), 1.0);
@@ -773,6 +762,8 @@ fn ops() {
     assert_eq(f64::NAN.max(-9.0), -9.0);
     assert_eq((9.0 as f64).min(f64::NAN), 9.0);
     assert_eq((-9.0 as f64).max(f64::NAN), -9.0);
+    assert_eq(F64_SNAN.min(9.0), 9.0);
+    assert_eq((-9.0_f64).max(F64_SNAN), -9.0);
 
     // f128 min/max
     assert_eq((1.0_f128).max(-1.0), 1.0);
@@ -781,6 +772,8 @@ fn ops() {
     assert_eq(f128::NAN.max(-9.0), -9.0);
     assert_eq((9.0_f128).min(f128::NAN), 9.0);
     assert_eq((-9.0_f128).max(f128::NAN), -9.0);
+    assert_eq(F128_SNAN.min(9.0), 9.0);
+    assert_eq((-9.0_f128).max(F128_SNAN), -9.0);
 
     // f16 copysign
     assert_eq(3.5_f16.copysign(0.42), 3.5_f16);
@@ -1548,15 +1541,15 @@ fn test_non_determinism() {
     test_operations_f128(25., 18.);
 
     // SNaN^0 = (1 | NaN)
-    check_nondet(|| f32::powf(SNAN_F32, 0.0).is_nan());
-    check_nondet(|| f64::powf(SNAN_F64, 0.0).is_nan());
+    check_nondet(|| f32::powf(F32_SNAN, 0.0).is_nan());
+    check_nondet(|| f64::powf(F64_SNAN, 0.0).is_nan());
 
     // 1^SNaN = (1 | NaN)
-    check_nondet(|| f32::powf(1.0, SNAN_F32).is_nan());
-    check_nondet(|| f64::powf(1.0, SNAN_F64).is_nan());
+    check_nondet(|| f32::powf(1.0, F32_SNAN).is_nan());
+    check_nondet(|| f64::powf(1.0, F64_SNAN).is_nan());
 
     // same as powf (keep it consistent):
     // x^SNaN = (1 | NaN)
-    check_nondet(|| f32::powi(SNAN_F32, 0).is_nan());
-    check_nondet(|| f64::powi(SNAN_F64, 0).is_nan());
+    check_nondet(|| f32::powi(F32_SNAN, 0).is_nan());
+    check_nondet(|| f64::powi(F64_SNAN, 0).is_nan());
 }