refactor fixed_float_int_value into fixed_powi_value and fixed_scalbn_value

Author: LorrensP-2158466

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

@@ -347,17 +347,16 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f = this.read_scalar(f)?.to_f32()?;
                 let i = this.read_scalar(i)?.to_i32()?;
 
-                let res =
-                    math::fixed_float_int_value(this, intrinsic_name, f, i).unwrap_or_else(|| {
-                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                        let res = f.to_host().powi(i).to_soft();
+                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                    let res = f.to_host().powi(i).to_soft();
 
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        math::apply_random_float_error_ulp(
-                            this, res, 2, // log2(4)
-                        )
-                    });
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    math::apply_random_float_error_ulp(
+                        this, res, 2, // log2(4)
+                    )
+                });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
@@ -366,17 +365,16 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let f = this.read_scalar(f)?.to_f64()?;
                 let i = this.read_scalar(i)?.to_i32()?;
 
-                let res =
-                    math::fixed_float_int_value(this, intrinsic_name, f, i).unwrap_or_else(|| {
-                        // Using host floats (but it's fine, this operation does not have guaranteed precision).
-                        let res = f.to_host().powi(i).to_soft();
+                let res = math::fixed_powi_value(this, f, i).unwrap_or_else(|| {
+                    // Using host floats (but it's fine, this operation does not have guaranteed precision).
+                    let res = f.to_host().powi(i).to_soft();
 
-                        // Apply a relative error of 4ULP to introduce some non-determinism
-                        // simulating imprecise implementations and optimizations.
-                        math::apply_random_float_error_ulp(
-                            this, res, 2, // log2(4)
-                        )
-                    });
+                    // Apply a relative error of 4ULP to introduce some non-determinism
+                    // simulating imprecise implementations and optimizations.
+                    math::apply_random_float_error_ulp(
+                        this, res, 2, // log2(4)
+                    )
+                });
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }

src/tools/miri/src/math.rs

@@ -260,44 +260,42 @@ where
     })
 }
 
-/// # 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 f (as a float) and int (as a i32) 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 `powif*` operations of the form `(SNaN)^(±0)` we follow the same behaviour as `powf*`, see [`fixed_float_value`].
-pub(crate) fn fixed_float_int_value<S: Semantics>(
+/// Returns `Some(output)` if `powi` (called `pown` in C) results in a fixed value specified in the
+/// C standard (specifically, C23 annex F.10.4.6) when doing `base^exp`. Otherwise, returns `None`.
+pub(crate) fn fixed_powi_value<S: Semantics>(
     ecx: &mut MiriInterpCx<'_>,
-    operation: &str,
-    f: IeeeFloat<S>,
-    int: i32,
+    base: IeeeFloat<S>,
+    exp: i32,
 ) -> Option<IeeeFloat<S>>
 where
     IeeeFloat<S>: IeeeExt,
 {
-    let this = ecx.eval_context_mut();
-
-    Some(match (operation, f, int) {
-        ("powif32" | "powif64", x, 0) => {
+    match exp {
+        0 => {
             let one = IeeeFloat::<S>::one();
-            let rng = this.machine.rng.get_mut();
-            let return_nan = this.machine.float_nondet && rng.random() && x.is_signaling();
+            let rng = ecx.machine.rng.get_mut();
+            let return_nan = ecx.machine.float_nondet && rng.random() && base.is_signaling();
             // For SNaN treatment, we are consistent with `powf`above.
             // (We wouldn't have two, unlike powf all implementations seem to agree for powi,
             // but for now we are maximally conservative.)
-            if return_nan { this.generate_nan(&[x]) } else { one }
+            Some(if return_nan { ecx.generate_nan(&[base]) } else { one })
         }
 
-        // For radix-2 (binary) systems, `ldexp` and `scalbn` are the same.
-        // scalbn(x, 0) = x.
-        ("_ldexp" | "ldexp" | "scalbn", x, 0) => x,
+        _ => return None,
+    }
+}
 
+/// Returns `Some(output)` if `scalbn` (called `ldexp` in C) results in a fixed value specified in the
+/// C standard (specifically, C23 annex F.10.3.19) when doing `arg`*(2^`exp`). Otherwise, returns `None`.
+pub(crate) fn fixed_scalbn_value<S: Semantics>(
+    arg: IeeeFloat<S>,
+    exp: i32,
+) -> Option<IeeeFloat<S>> {
+    match exp {
+        // ldexp(x, 0) = x.
+        0 => Some(arg),
         _ => return None,
-    })
+    }
 }
 
 pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFloat<S> {

src/tools/miri/src/shims/foreign_items.rs

@@ -933,7 +933,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let exp = this.read_scalar(exp)?.to_i32()?;
 
                 let res =
-                    math::fixed_float_int_value(this, link_name.as_str(), x, exp).unwrap_or_else(|| {
+                    math::fixed_scalbn_value(x, exp).unwrap_or_else(|| {
                         let res = x.scalbn(exp);
                         // Apply a relative error of 4ULP to introduce some non-determinism
                         // simulating imprecise implementations and optimizations.