apply requests from reviewer

Author: LorrensP-2158466

src/tools/miri/src/intrinsics/mod.rs

@@ -6,7 +6,6 @@ mod simd;
 use std::ops::Neg;
 
 use rand::Rng;
-use rand::rngs::StdRng;
 use rustc_abi::Size;
 use rustc_apfloat::ieee::{IeeeFloat, Semantics};
 use rustc_apfloat::{self, Float, Round};
@@ -18,6 +17,7 @@ use self::atomic::EvalContextExt as _;
 use self::helpers::{ToHost, ToSoft, check_intrinsic_arg_count};
 use self::simd::EvalContextExt as _;
 use crate::math::{IeeeExt, apply_random_float_error_ulp};
+use crate::operator::EvalContextExt as _;
 use crate::*;
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -490,15 +490,6 @@ fn apply_random_float_error_to_imm<'tcx>(
     interp_ok(ImmTy::from_scalar_int(res, val.layout))
 }
 
-/// Returns either a SNaN or a QNaN, with a randomly generated payload.
-fn random_nan<S: Semantics>(rng: &mut StdRng) -> IeeeFloat<S> {
-    if rng.random() {
-        IeeeFloat::<S>::snan(Some(rng.random()))
-    } else {
-        IeeeFloat::<S>::qnan(Some(rng.random()))
-    }
-}
-
 /// For the intrinsics:
 /// - sinf32, sinf64
 /// - cosf32, cosf64
@@ -547,15 +538,17 @@ fn fixed_float_value<S: Semantics>(
         // 1^y = 1 for any y, even a NaN, *but* not a SNaN
         ("powf32" | "powf64", [base, exp]) if *base == one => {
             let rng = ecx.machine.rng.get_mut();
+            let return_nan = ecx.machine.float_nondet && rng.random() && exp.is_signaling();
             // Handle both the musl and glibc cases non-deterministically.
-            if !exp.is_signaling() || rng.random() { one } else { random_nan(rng) }
+            if return_nan { ecx.generate_nan(args) } else { one }
         }
 
         // x^(±0) = 1 for any x, even a NaN, *but* not a SNaN
         ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
             let rng = ecx.machine.rng.get_mut();
+            let return_nan = ecx.machine.float_nondet && rng.random() && base.is_signaling();
             // Handle both the musl and glibc cases non-deterministically.
-            if !base.is_signaling() || rng.random() { one } else { random_nan(rng) }
+            if return_nan { ecx.generate_nan(args) } else { one }
         }
 
         // There are a lot of cases for fixed outputs according to the C Standard, but these are mainly INF or zero
@@ -576,9 +569,10 @@ fn fixed_powi_float_value<S: Semantics>(
         0 => {
             let one = IeeeFloat::<S>::one();
             let rng = ecx.machine.rng.get_mut();
+            let return_nan = ecx.machine.float_nondet && rng.random() && base.is_signaling();
             Some(
                 // Handle both the musl and glibc powf cases non-deterministically.
-                if !base.is_signaling() || rng.random() { one } else { random_nan(rng) },
+                if return_nan { ecx.generate_nan(&[base]) } else { one },
             )
         }
 

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

@@ -1066,39 +1066,6 @@ pub fn libm() {
     assert_eq!((-1f32).powf(f32::NEG_INFINITY), 1.0);
     assert_eq!((-1f64).powf(f64::NEG_INFINITY), 1.0);
 
-    // Makes sure an operations returns both `1` and a `NaN` randomly.
-    macro_rules! test_snan_nondet {
-        ($pow_op:expr) => {{
-            let mut nan_seen = false;
-            let mut one_seen = false;
-
-            for _ in 0..64 {
-                let res = $pow_op;
-                nan_seen |= res.is_nan();
-                one_seen |= res == 1.0;
-
-                // little speedup
-                if nan_seen && one_seen { break; };
-            }
-
-            let op_as_str = stringify!($pow_op);
-
-            assert!(nan_seen && one_seen, "{} should return both `NaN` or `1.0` randomly", op_as_str);
-        }};
-    }
-
-    // x^(SNaN) = (1 | NaN)
-    test_snan_nondet!(f32::powf(SNAN_F32, 0.0));
-    test_snan_nondet!(f64::powf(SNAN_F64, 0.0));
-
-    // 1^(SNaN) = (1 | NaN)
-    test_snan_nondet!(f32::powf(1.0, SNAN_F32));
-    test_snan_nondet!(f64::powf(1.0, SNAN_F64));
-
-    // same as powf (keep it consistent):
-    // x^(SNaN) = (1 | NaN)
-    test_snan_nondet!(f32::powi(SNAN_F32, 0));
-    test_snan_nondet!(f64::powi(SNAN_F64, 0));
 
     assert_eq!(0f32.powi(10), 0.0);
     assert_eq!(0f64.powi(100), 0.0);
@@ -1522,4 +1489,18 @@ fn test_non_determinism() {
     test_operations_f32(12., 5.);
     test_operations_f64(19., 11.);
     test_operations_f128(25., 18.);
+
+
+    // x^(SNaN) = (1 | NaN)
+    ensure_nondet(|| f32::powf(SNAN_F32, 0.0));
+    ensure_nondet(|| f64::powf(SNAN_F64, 0.0));
+
+    // 1^(SNaN) = (1 | NaN)
+    ensure_nondet(|| f32::powf(1.0, SNAN_F32));
+    ensure_nondet(|| f64::powf(1.0, SNAN_F64));
+
+    // same as powf (keep it consistent):
+    // x^(SNaN) = (1 | NaN)
+    ensure_nondet(|| f32::powi(SNAN_F32, 0));
+    ensure_nondet(|| f64::powi(SNAN_F64, 0));
 }