move the entire floating point error distribution into helper fn

Author: RalfJung

src/shims/x86/sse.rs

@@ -522,40 +522,39 @@ fn unary_op_f32<'tcx>(
         }
         FloatUnaryOp::Rcp => {
             let op = op.to_scalar().to_f32()?;
-            // Calculate 1 / x and multiply the result by 1 + err (where err
-            // is a random value with a magnitude in the order of 2^-12) to
-            // simulate the inaccuracy of RCP.
-            let one = Single::from_u128(1).value;
-            let err = gen_random_float_error(this, -12);
-            let res = ((one / op).value * (one + err).value).value;
+            let div = (Single::from_u128(1).value / op).value;
+            // Apply a relative error with a magnitude on the order of 2^-12 to simulate the
+            // inaccuracy of RCP.
+            let res = apply_random_float_error(this, div, -12);
             Ok(Scalar::from_f32(res))
         }
         FloatUnaryOp::Rsqrt => {
             let op = op.to_scalar().to_u32()?;
-            // Calculate 1 / sqrt(x) and multiply the result by 1 + err (where
-            // err is a random value with a magnitude in the order of 2^-12) to
-            // simulate the inaccuracy of RSQRT.
             // FIXME using host floats
             let sqrt = Single::from_bits(f32::from_bits(op).sqrt().to_bits().into());
-            let one = Single::from_u128(1).value;
-            let err = gen_random_float_error(this, -12);
-            let res = ((one / sqrt).value * (one + err).value).value;
+            // Apply a relative error with a magnitude on the order of 2^-12 to simulate the
+            // inaccuracy of RSQRT.
+            let res = apply_random_float_error(this, sqrt, -12);
             Ok(Scalar::from_f32(res))
         }
     }
 }
 
-/// Returns a random a value in the range (-2^scale, 2^scale)
-fn gen_random_float_error<F: rustc_apfloat::Float>(
+/// Disturbes a floating-point result by a relative error on the order of (-2^scale, 2^scale).
+#[allow(clippy::arithmetic_side_effects)] // floating point arithmetic cannot panic
+fn apply_random_float_error<F: rustc_apfloat::Float>(
     this: &mut crate::MiriInterpCx<'_, '_>,
-    scale: i32,
+    val: F,
+    err_scale: i32,
 ) -> F {
     let rng = this.machine.rng.get_mut();
     // generates rand(0, 2^64) * 2^(scale - 64) = rand(0, 1) * 2^scale
-    let v = F::from_u128(rng.gen::<u64>().into()).value.scalbn(scale.checked_sub(64).unwrap());
+    let err =
+        F::from_u128(rng.gen::<u64>().into()).value.scalbn(err_scale.checked_sub(64).unwrap());
     // give it a random sign
-    #[allow(clippy::arithmetic_side_effects)] // floating point negation cannot panic
-    if rng.gen::<bool>() { -v } else { v }
+    let err = if rng.gen::<bool>() { -err } else { err };
+    // multiple the value with (1+err)
+    (val * (F::from_u128(1).value + err).value).value
 }
 
 /// Performs `which` operation on the first component of `op` and copies