implement powf(1, SNaN) non-det

Author: LorrensP-2158466

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

@@ -518,6 +518,13 @@ fn random_nan<S: Semantics>(rng: &mut StdRng) -> IeeeFloat<S> {
 /// - logf32, logf64, log2f32, log2f64, log10f32, log10f64
 /// - powf32, powf64
 ///
+/// # Return
+///
+/// Returns `Some(output)` if the `intrinsic` results in a defined fixed `output` specified in the C standard
+/// (specifically, C23 annex F.10)  when given `args` as arguments. Outputs that are unaffected by a relative error
+/// (such as INF and zero) are not handled here, they are assumed to be handled by the underlying
+/// implementation. Returns `None` if no specific value is guaranteed.
+///
 /// # Note
 ///
 /// For `powf*` operations of the form:
@@ -532,12 +539,7 @@ fn random_nan<S: Semantics>(rng: &mut StdRng) -> IeeeFloat<S> {
 /// This discrepancy exists because SNaN handling is not consistently defined across platforms,
 /// and the C standard leaves behavior for SNaNs unspecified.
 ///
-/// # Return
-///
-/// Returns `Some(output)` if the `intrinsic` results in a defined fixed `output` specified in the C standard
-/// (specifically, C23 annex F.10)  when given `args` as arguments. Outputs that are unaffected by a relative error
-/// (such as INF and zero) are not handled here, they are assumed to be handled by the underlying
-/// implementation. Returns `None` if no specific value is guaranteed.
+/// Miri chooses to adhere to both implementations and returns either one of them non-deterministically.
 fn fixed_float_value<'tcx, S: Semantics>(
     ecx: &mut MiriInterpCx<'tcx>,
     intrinsic_name: &str,
@@ -551,12 +553,15 @@ fn fixed_float_value<'tcx, S: Semantics>(
         // e^0 = 1
         ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
 
-        // 1^y = 1 for any y, even a NaN
-        ("powf32" | "powf64", [base, _]) if *base == one => one,
-
         // (-1)^(±INF) = 1
         ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
 
+        // 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();
+            // Handle both the musl and glibc cases non-deterministically.
+            if !exp.is_signaling() || rng.random() { one } else { random_nan(rng) }
+        }
         // x^(±0) = 1 for any x, even a NaN, *but* not a SNaN
         ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
             // Handle both the musl and glibc cases non-deterministically.

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

@@ -1067,25 +1067,34 @@ pub fn libm() {
     assert_eq!((-1f32).powf(f32::NEG_INFINITY), 1.0);
     assert_eq!((-1f64).powf(f64::NEG_INFINITY), 1.0);
 
-    macro_rules! test_snan_pow {
-        ($snan:expr, $pow_op:path) => {{
+    // 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($snan, 0 as _);
+                let res = $pow_op;
                 nan_seen |= res.is_nan();
                 one_seen |= res == 1.0;
+
+                // speedup test
+                if nan_seen && one_seen { break; };
             }
 
             let op_as_str = stringify!($pow_op);
 
-            assert!(nan_seen && one_seen, "{}(SNaN, 0) should return both `NaN` or `1.0` randomly", op_as_str);
+            assert!(nan_seen && one_seen, "{} should return both `NaN` or `1.0` randomly", op_as_str);
         }};
     }
 
-    test_snan_pow!(SNAN_F32, f32::powf);
-    test_snan_pow!(SNAN_F64, f64::powf);
+    // 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));
 
 
     // For pown (powi in rust) the C standard says: