move float nondet helpers to math.rs

Author: LorrensP-2158466

src/tools/miri/src/helpers.rs

@@ -1,12 +1,11 @@
 use std::num::NonZero;
-use std::ops::Neg;
 use std::time::Duration;
 use std::{cmp, iter};
 
-use rand::{Rng, RngCore};
+use rand::RngCore;
 use rustc_abi::{Align, CanonAbi, ExternAbi, FieldIdx, FieldsShape, Size, Variants};
 use rustc_apfloat::Float;
-use rustc_apfloat::ieee::{Double, Half, IeeeFloat, Quad, Semantics, Single};
+use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_hir::Safety;
 use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::def_id::{CRATE_DEF_INDEX, CrateNum, DefId, LOCAL_CRATE};
@@ -15,13 +14,12 @@ use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::middle::exported_symbols::ExportedSymbol;
 use rustc_middle::ty::layout::{LayoutOf, MaybeResult, TyAndLayout};
-use rustc_middle::ty::{self, Binder, FloatTy, FnSig, IntTy, ScalarInt, Ty, TyCtxt, UintTy};
+use rustc_middle::ty::{self, Binder, FloatTy, FnSig, IntTy, Ty, TyCtxt, UintTy};
 use rustc_session::config::CrateType;
 use rustc_span::{Span, Symbol};
 use rustc_symbol_mangling::mangle_internal_symbol;
 use rustc_target::callconv::FnAbi;
 
-use crate::math::{IeeeExt, apply_random_float_error_ulp};
 use crate::*;
 
 /// Indicates which kind of access is being performed.
@@ -217,57 +215,6 @@ impl ToSoft for f32 {
     }
 }
 
-/// Given a floating-point operation and a floating-point value, clamps the result to the output
-/// range of the given operation according to the C standard, if any.
-pub fn clamp_float_value<S: Semantics>(intrinsic_name: &str, val: IeeeFloat<S>) -> IeeeFloat<S>
-where
-    IeeeFloat<S>: IeeeExt,
-{
-    let zero = IeeeFloat::<S>::ZERO;
-    let one = IeeeFloat::<S>::one();
-    let two = IeeeFloat::<S>::two();
-    let pi = IeeeFloat::<S>::pi();
-    let pi_over_2 = (pi / two).value;
-
-    match intrinsic_name {
-        // sin, cos, tanh: [-1, 1]
-        #[rustfmt::skip]
-        | "sinf32"
-        | "sinf64"
-        | "cosf32"
-        | "cosf64"
-        | "tanhf"
-        | "tanh"
-         => val.clamp(one.neg(), one),
-
-        // exp: [0, +INF)
-        "expf32" | "exp2f32" | "expf64" | "exp2f64" => val.maximum(zero),
-
-        // cosh: [1, +INF)
-        "coshf" | "cosh" => val.maximum(one),
-
-        // acos: [0, π]
-        "acosf" | "acos" => val.clamp(zero, pi),
-
-        // asin: [-π, +π]
-        "asinf" | "asin" => val.clamp(pi.neg(), pi),
-
-        // atan: (-π/2, +π/2)
-        "atanf" | "atan" => val.clamp(pi_over_2.neg(), pi_over_2),
-
-        // erfc: (-1, 1)
-        "erff" | "erf" => val.clamp(one.neg(), one),
-
-        // erfc: (0, 2)
-        "erfcf" | "erfc" => val.clamp(zero, two),
-
-        // atan2(y, x): arctan(y/x) in [−π, +π]
-        "atan2f" | "atan2" => val.clamp(pi.neg(), pi),
-
-        _ => val,
-    }
-}
-
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Checks if the given crate/module exists.
@@ -1252,200 +1199,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
     }
 
-    /// Applies a random ULP floating point error to `val` and returns the new value.
-    /// So if you want an X ULP error, `ulp_exponent` should be log2(X).
-    ///
-    /// Will fail if `val` is not a floating point number.
-    fn apply_random_float_error_to_imm(
-        &mut self,
-        val: ImmTy<'tcx>,
-        ulp_exponent: u32,
-    ) -> InterpResult<'tcx, ImmTy<'tcx>> {
-        let this = self.eval_context_mut();
-        let scalar = val.to_scalar_int()?;
-        let res: ScalarInt = match val.layout.ty.kind() {
-            ty::Float(FloatTy::F16) =>
-                apply_random_float_error_ulp(this, scalar.to_f16(), ulp_exponent).into(),
-            ty::Float(FloatTy::F32) =>
-                apply_random_float_error_ulp(this, scalar.to_f32(), ulp_exponent).into(),
-            ty::Float(FloatTy::F64) =>
-                apply_random_float_error_ulp(this, scalar.to_f64(), ulp_exponent).into(),
-            ty::Float(FloatTy::F128) =>
-                apply_random_float_error_ulp(this, scalar.to_f128(), ulp_exponent).into(),
-            _ => bug!("intrinsic called with non-float input type"),
-        };
-
-        interp_ok(ImmTy::from_scalar_int(res, val.layout))
-    }
-
-    /// For the intrinsics:
-    /// - sinf32, sinf64, sinhf, sinh
-    /// - cosf32, cosf64, coshf, cosh
-    /// - tanhf, tanh, atanf, atan, atan2f, atan2
-    /// - expf32, expf64, exp2f32, exp2f64
-    /// - logf32, logf64, log2f32, log2f64, log10f32, log10f64
-    /// - powf32, powf64
-    /// - erff, erf, erfcf, erfc
-    /// - hypotf, hypot
-    ///
-    /// # 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:
-    ///
-    /// - `(SNaN)^(±0)`
-    /// - `1^(SNaN)`
-    ///
-    /// The result is implementation-defined:
-    /// - musl returns for both `1.0`
-    /// - glibc returns for both `NaN`
-    ///
-    /// This discrepancy exists because SNaN handling is not consistently defined across platforms,
-    /// and the C standard leaves behavior for SNaNs unspecified.
-    ///
-    /// Miri chooses to adhere to both implementations and returns either one of them non-deterministically.
-    fn fixed_float_value<S: Semantics>(
-        &mut self,
-        intrinsic_name: &str,
-        args: &[IeeeFloat<S>],
-    ) -> Option<IeeeFloat<S>>
-    where
-        IeeeFloat<S>: IeeeExt,
-    {
-        let this = self.eval_context_mut();
-        let one = IeeeFloat::<S>::one();
-        let two = IeeeFloat::<S>::two();
-        let three = IeeeFloat::<S>::three();
-        let pi = IeeeFloat::<S>::pi();
-        let pi_over_2 = (pi / two).value;
-        let pi_over_4 = (pi_over_2 / two).value;
-
-        Some(match (intrinsic_name, args) {
-            // cos(±0) and cosh(±0)= 1
-            ("cosf32" | "cosf64" | "coshf" | "cosh", [input]) if input.is_zero() => one,
-
-            // e^0 = 1
-            ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
-
-            // tanh(±INF) = ±1
-            ("tanhf" | "tanh", [input]) if input.is_infinite() => one.copy_sign(*input),
-
-            // atan(±INF) = ±π/2
-            ("atanf" | "atan", [input]) if input.is_infinite() => pi_over_2.copy_sign(*input),
-
-            // erf(±INF) = ±1
-            ("erff" | "erf", [input]) if input.is_infinite() => one.copy_sign(*input),
-
-            // erfc(-INF) = 2
-            ("erfcf" | "erfc", [input]) if input.is_neg_infinity() => (one + one).value,
-
-            // hypot(x, ±0) = abs(x), if x is not a NaN.
-            ("_hypotf" | "hypotf" | "_hypot" | "hypot", [x, y]) if !x.is_nan() && y.is_zero() =>
-                x.abs(),
-
-            // atan2(±0,−0) = ±π.
-            // atan2(±0, y) = ±π for y < 0.
-            // Must check for non NaN because `y.is_negative()` also applies to NaN.
-            ("atan2f" | "atan2", [x, y]) if (x.is_zero() && (y.is_negative() && !y.is_nan())) =>
-                pi.copy_sign(*x),
-
-            // atan2(±x,−∞) = ±π for finite x > 0.
-            ("atan2f" | "atan2", [x, y])
-                if (!x.is_zero() && !x.is_infinite()) && y.is_neg_infinity() =>
-                pi.copy_sign(*x),
-
-            // atan2(x, ±0) = −π/2 for x < 0.
-            // atan2(x, ±0) =  π/2 for x > 0.
-            // REVIEW: Above is from C23, do we simplify this to the following?
-            // atan2(±x, 0) = ±π/2 if x is non-zero
-            ("atan2f" | "atan2", [x, y]) if !x.is_zero() && y.is_zero() => pi_over_2.copy_sign(*x),
-
-            //atan2(±∞, −∞) = ±3π/4
-            ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_neg_infinity() =>
-                (pi_over_4 * three).value.copy_sign(*x),
-
-            //atan2(±∞, +∞) = ±π/4
-            ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_pos_infinity() =>
-                pi_over_4.copy_sign(*x),
-
-            // atan2(±∞, y) returns ±π/2 for finite y.
-            ("atan2f" | "atan2", [x, y])
-                if x.is_infinite() && (!y.is_infinite() && !y.is_nan()) =>
-                pi_over_2.copy_sign(*x),
-
-            // (-1)^(±INF) = 1
-            ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
-
-            // 1^y = 1 for any y, even a NaN
-            ("powf32" | "powf64", [base, exp]) if *base == one => {
-                let rng = this.machine.rng.get_mut();
-                // SNaN exponents get special treatment: they might return 1, or a NaN.
-                let return_nan = exp.is_signaling() && this.machine.float_nondet && rng.random();
-                // Handle both the musl and glibc cases non-deterministically.
-                if return_nan { this.generate_nan(args) } else { one }
-            }
-
-            // x^(±0) = 1 for any x, even a NaN
-            ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
-                let rng = this.machine.rng.get_mut();
-                // SNaN bases get special treatment: they might return 1, or a NaN.
-                let return_nan = base.is_signaling() && this.machine.float_nondet && rng.random();
-                // Handle both the musl and glibc cases non-deterministically.
-                if return_nan { this.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 which are not affected by the applied error.
-            _ => return None,
-        })
-    }
-
-    /// # 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`].
-    fn fixed_float_int_value<S: Semantics>(
-        &mut self,
-        operation: &str,
-        f: IeeeFloat<S>,
-        int: i32,
-    ) -> Option<IeeeFloat<S>>
-    where
-        IeeeFloat<S>: IeeeExt,
-    {
-        let this = self.eval_context_mut();
-
-        Some(match (operation, f, int) {
-            ("powif32" | "powif64", x, 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();
-                // 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 }
-            }
-
-            // For radix-2 (binary) systems, `ldexp` and `scalbn` are the same.
-            // scalbn(x, 0) = x.
-            ("_ldexp" | "ldexp" | "scalbn", x, 0) => x,
-
-            _ => return None,
-        })
-    }
-
     /// Returns an integer type that is twice wide as `ty`
     fn get_twice_wide_int_ty(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
         let this = self.eval_context_ref();