Auto merge of #148446 - GuillaumeGomez:rollup-lxwlqol, r=GuillaumeGomez

bors · bors · commit a2f0023eb901 · 2025-11-03T16:29:59.000Z
Rollup of 8 pull requests Successful merges: - rust-lang/rust#135099 (Add FileCheck annotations to mir-opt/copy-prop) - rust-lang/rust#145903 (Give correct suggestion for a typo in raw pointers) - rust-lang/rust#147520 (Port the remaining SIMD intrinsics to const-eval) - rust-lang/rust#148068 (rustdoc: Use configured target modifiers when collecting doctests) - rust-lang/rust#148099 (Prepare to move debugger discovery from compiletest to bootstrap) - rust-lang/rust#148268 (rustdoc: fix `--emit=dep-info` on scraped examples) - rust-lang/rust#148306 (Remove double check when decoding ExpnId to avoid races) - rust-lang/rust#148378 (Fix documentation for std::panic::update_hook) r? `@ghost` `@rustbot` modify labels: rollup
diff --git a/src/intrinsics/simd.rs b/src/intrinsics/simd.rs
@@ -1,5 +1,3 @@
-use rand::Rng;
-use rustc_apfloat::Float;
 use rustc_middle::ty;
 use rustc_middle::ty::FloatTy;
 
@@ -83,62 +81,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.write_scalar(val, &dest)?;
                 }
             }
-            "fma" | "relaxed_fma" => {
-                let [a, b, c] = check_intrinsic_arg_count(args)?;
-                let (a, a_len) = this.project_to_simd(a)?;
-                let (b, b_len) = this.project_to_simd(b)?;
-                let (c, c_len) = this.project_to_simd(c)?;
-                let (dest, dest_len) = this.project_to_simd(dest)?;
-
-                assert_eq!(dest_len, a_len);
-                assert_eq!(dest_len, b_len);
-                assert_eq!(dest_len, c_len);
-
-                for i in 0..dest_len {
-                    let a = this.read_scalar(&this.project_index(&a, i)?)?;
-                    let b = this.read_scalar(&this.project_index(&b, i)?)?;
-                    let c = this.read_scalar(&this.project_index(&c, i)?)?;
-                    let dest = this.project_index(&dest, i)?;
-
-                    let fuse: bool = intrinsic_name == "fma"
-                        || (this.machine.float_nondet && this.machine.rng.get_mut().random());
-
-                    // Works for f32 and f64.
-                    // FIXME: using host floats to work around https://github.com/rust-lang/miri/issues/2468.
-                    let ty::Float(float_ty) = dest.layout.ty.kind() else {
-                        span_bug!(this.cur_span(), "{} operand is not a float", intrinsic_name)
-                    };
-                    let val = match float_ty {
-                        FloatTy::F16 => unimplemented!("f16_f128"),
-                        FloatTy::F32 => {
-                            let a = a.to_f32()?;
-                            let b = b.to_f32()?;
-                            let c = c.to_f32()?;
-                            let res = if fuse {
-                                a.mul_add(b, c).value
-                            } else {
-                                ((a * b).value + c).value
-                            };
-                            let res = this.adjust_nan(res, &[a, b, c]);
-                            Scalar::from(res)
-                        }
-                        FloatTy::F64 => {
-                            let a = a.to_f64()?;
-                            let b = b.to_f64()?;
-                            let c = c.to_f64()?;
-                            let res = if fuse {
-                                a.mul_add(b, c).value
-                            } else {
-                                ((a * b).value + c).value
-                            };
-                            let res = this.adjust_nan(res, &[a, b, c]);
-                            Scalar::from(res)
-                        }
-                        FloatTy::F128 => unimplemented!("f16_f128"),
-                    };
-                    this.write_scalar(val, &dest)?;
-                }
-            }
             "expose_provenance" => {
                 let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
diff --git a/src/machine.rs b/src/machine.rs
@@ -1347,8 +1347,8 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
     }
 
     #[inline(always)]
-    fn float_fuse_mul_add(ecx: &mut InterpCx<'tcx, Self>) -> bool {
-        ecx.machine.float_nondet && ecx.machine.rng.get_mut().random()
+    fn float_fuse_mul_add(ecx: &InterpCx<'tcx, Self>) -> bool {
+        ecx.machine.float_nondet && ecx.machine.rng.borrow_mut().random()
     }
 
     #[inline(always)]
diff --git a/tests/pass/intrinsics/portable-simd.rs b/tests/pass/intrinsics/portable-simd.rs
@@ -6,18 +6,143 @@
     rustc_attrs,
     intrinsics,
     core_intrinsics,
-    repr_simd
+    repr_simd,
+    f16,
+    f128
 )]
-#![allow(incomplete_features, internal_features)]
+#![allow(incomplete_features, internal_features, non_camel_case_types)]
+use std::fmt::{self, Debug, Formatter};
 use std::intrinsics::simd as intrinsics;
 use std::ptr;
 use std::simd::StdFloat;
 use std::simd::prelude::*;
 
+#[repr(simd, packed)]
+#[derive(Copy)]
+struct PackedSimd<T, const N: usize>([T; N]);
+
+impl<T: Copy, const N: usize> Clone for PackedSimd<T, N> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: PartialEq + Copy, const N: usize> PartialEq for PackedSimd<T, N> {
+    fn eq(&self, other: &Self) -> bool {
+        self.into_array() == other.into_array()
+    }
+}
+
+impl<T: Debug + Copy, const N: usize> Debug for PackedSimd<T, N> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Debug::fmt(&self.into_array(), f)
+    }
+}
+
+type f16x2 = PackedSimd<f16, 2>;
+type f16x4 = PackedSimd<f16, 4>;
+
+type f128x2 = PackedSimd<f128, 2>;
+type f128x4 = PackedSimd<f128, 4>;
+
+impl<T: Copy, const N: usize> PackedSimd<T, N> {
+    fn splat(x: T) -> Self {
+        Self([x; N])
+    }
+    fn from_array(a: [T; N]) -> Self {
+        Self(a)
+    }
+    fn into_array(self) -> [T; N] {
+        // as we have `repr(packed)`, there shouldn't be any padding bytes
+        unsafe { std::mem::transmute_copy(&self) }
+    }
+}
+
 #[rustc_intrinsic]
 #[rustc_nounwind]
 pub unsafe fn simd_shuffle_const_generic<T, U, const IDX: &'static [u32]>(x: T, y: T) -> U;
 
+pub fn simd_ops_f16() {
+    use intrinsics::*;
+
+    // small hack to make type inference better
+    macro_rules! assert_eq {
+        ($a:expr, $b:expr $(,$t:tt)*) => {{
+            let a = $a;
+            let b = $b;
+            if false { let _inference = b == a; }
+            ::std::assert_eq!(a, b, $(,$t)*)
+        }}
+    }
+
+    let a = f16x4::splat(10.0);
+    let b = f16x4::from_array([1.0, 2.0, 3.0, -4.0]);
+
+    unsafe {
+        assert_eq!(simd_neg(b), f16x4::from_array([-1.0, -2.0, -3.0, 4.0]));
+        assert_eq!(simd_add(a, b), f16x4::from_array([11.0, 12.0, 13.0, 6.0]));
+        assert_eq!(simd_sub(a, b), f16x4::from_array([9.0, 8.0, 7.0, 14.0]));
+        assert_eq!(simd_mul(a, b), f16x4::from_array([10.0, 20.0, 30.0, -40.0]));
+        assert_eq!(simd_div(b, a), f16x4::from_array([0.1, 0.2, 0.3, -0.4]));
+        assert_eq!(simd_div(a, f16x4::splat(2.0)), f16x4::splat(5.0));
+        assert_eq!(simd_rem(a, b), f16x4::from_array([0.0, 0.0, 1.0, 2.0]));
+        assert_eq!(simd_fabs(b), f16x4::from_array([1.0, 2.0, 3.0, 4.0]));
+        assert_eq!(
+            simd_fmax(a, simd_mul(b, f16x4::splat(4.0))),
+            f16x4::from_array([10.0, 10.0, 12.0, 10.0])
+        );
+        assert_eq!(
+            simd_fmin(a, simd_mul(b, f16x4::splat(4.0))),
+            f16x4::from_array([4.0, 8.0, 10.0, -16.0])
+        );
+
+        assert_eq!(simd_fma(a, b, a), simd_add(simd_mul(a, b), a));
+        assert_eq!(simd_fma(b, b, a), simd_add(simd_mul(b, b), a));
+        assert_eq!(simd_fma(a, b, b), simd_add(simd_mul(a, b), b));
+        assert_eq!(
+            simd_fma(f16x4::splat(-3.2), b, f16x4::splat(f16::NEG_INFINITY)),
+            f16x4::splat(f16::NEG_INFINITY)
+        );
+
+        assert_eq!(simd_relaxed_fma(a, b, a), simd_add(simd_mul(a, b), a));
+        assert_eq!(simd_relaxed_fma(b, b, a), simd_add(simd_mul(b, b), a));
+        assert_eq!(simd_relaxed_fma(a, b, b), simd_add(simd_mul(a, b), b));
+        assert_eq!(
+            simd_relaxed_fma(f16x4::splat(-3.2), b, f16x4::splat(f16::NEG_INFINITY)),
+            f16x4::splat(f16::NEG_INFINITY)
+        );
+
+        assert_eq!(simd_eq(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([0, !0, 0, 0]));
+        assert_eq!(simd_ne(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([!0, 0, !0, !0]));
+        assert_eq!(simd_le(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([0, !0, !0, 0]));
+        assert_eq!(simd_lt(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([0, 0, !0, 0]));
+        assert_eq!(simd_ge(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([!0, !0, 0, !0]));
+        assert_eq!(simd_gt(a, simd_mul(f16x4::splat(5.0), b)), i32x4::from_array([!0, 0, 0, !0]));
+
+        assert_eq!(simd_reduce_add_ordered(a, 0.0), 40.0f16);
+        assert_eq!(simd_reduce_add_ordered(b, 0.0), 2.0f16);
+        assert_eq!(simd_reduce_mul_ordered(a, 1.0), 10000.0f16);
+        assert_eq!(simd_reduce_mul_ordered(b, 1.0), -24.0f16);
+        assert_eq!(simd_reduce_max(a), 10.0f16);
+        assert_eq!(simd_reduce_max(b), 3.0f16);
+        assert_eq!(simd_reduce_min(a), 10.0f16);
+        assert_eq!(simd_reduce_min(b), -4.0f16);
+
+        assert_eq!(
+            simd_fmax(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
+            f16x2::from_array([0.0, 0.0])
+        );
+        assert_eq!(simd_reduce_max(f16x2::from_array([0.0, f16::NAN])), 0.0f16);
+        assert_eq!(simd_reduce_max(f16x2::from_array([f16::NAN, 0.0])), 0.0f16);
+        assert_eq!(
+            simd_fmin(f16x2::from_array([0.0, f16::NAN]), f16x2::from_array([f16::NAN, 0.0])),
+            f16x2::from_array([0.0, 0.0])
+        );
+        assert_eq!(simd_reduce_min(f16x2::from_array([0.0, f16::NAN])), 0.0f16);
+        assert_eq!(simd_reduce_min(f16x2::from_array([f16::NAN, 0.0])), 0.0f16);
+    }
+}
+
 fn simd_ops_f32() {
     let a = f32x4::splat(10.0);
     let b = f32x4::from_array([1.0, 2.0, 3.0, -4.0]);
@@ -148,6 +273,87 @@ fn simd_ops_f64() {
     assert_eq!(f64x2::from_array([f64::NAN, 0.0]).reduce_min(), 0.0);
 }
 
+pub fn simd_ops_f128() {
+    use intrinsics::*;
+
+    // small hack to make type inference better
+    macro_rules! assert_eq {
+        ($a:expr, $b:expr $(,$t:tt)*) => {{
+            let a = $a;
+            let b = $b;
+            if false { let _inference = b == a; }
+            ::std::assert_eq!(a, b, $(,$t)*)
+        }}
+    }
+
+    let a = f128x4::splat(10.0);
+    let b = f128x4::from_array([1.0, 2.0, 3.0, -4.0]);
+
+    unsafe {
+        assert_eq!(simd_neg(b), f128x4::from_array([-1.0, -2.0, -3.0, 4.0]));
+        assert_eq!(simd_add(a, b), f128x4::from_array([11.0, 12.0, 13.0, 6.0]));
+        assert_eq!(simd_sub(a, b), f128x4::from_array([9.0, 8.0, 7.0, 14.0]));
+        assert_eq!(simd_mul(a, b), f128x4::from_array([10.0, 20.0, 30.0, -40.0]));
+        assert_eq!(simd_div(b, a), f128x4::from_array([0.1, 0.2, 0.3, -0.4]));
+        assert_eq!(simd_div(a, f128x4::splat(2.0)), f128x4::splat(5.0));
+        assert_eq!(simd_rem(a, b), f128x4::from_array([0.0, 0.0, 1.0, 2.0]));
+        assert_eq!(simd_fabs(b), f128x4::from_array([1.0, 2.0, 3.0, 4.0]));
+        assert_eq!(
+            simd_fmax(a, simd_mul(b, f128x4::splat(4.0))),
+            f128x4::from_array([10.0, 10.0, 12.0, 10.0])
+        );
+        assert_eq!(
+            simd_fmin(a, simd_mul(b, f128x4::splat(4.0))),
+            f128x4::from_array([4.0, 8.0, 10.0, -16.0])
+        );
+
+        assert_eq!(simd_fma(a, b, a), simd_add(simd_mul(a, b), a));
+        assert_eq!(simd_fma(b, b, a), simd_add(simd_mul(b, b), a));
+        assert_eq!(simd_fma(a, b, b), simd_add(simd_mul(a, b), b));
+        assert_eq!(
+            simd_fma(f128x4::splat(-3.2), b, f128x4::splat(f128::NEG_INFINITY)),
+            f128x4::splat(f128::NEG_INFINITY)
+        );
+
+        assert_eq!(simd_relaxed_fma(a, b, a), simd_add(simd_mul(a, b), a));
+        assert_eq!(simd_relaxed_fma(b, b, a), simd_add(simd_mul(b, b), a));
+        assert_eq!(simd_relaxed_fma(a, b, b), simd_add(simd_mul(a, b), b));
+        assert_eq!(
+            simd_relaxed_fma(f128x4::splat(-3.2), b, f128x4::splat(f128::NEG_INFINITY)),
+            f128x4::splat(f128::NEG_INFINITY)
+        );
+
+        assert_eq!(simd_eq(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([0, !0, 0, 0]));
+        assert_eq!(simd_ne(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([!0, 0, !0, !0]));
+        assert_eq!(simd_le(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([0, !0, !0, 0]));
+        assert_eq!(simd_lt(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([0, 0, !0, 0]));
+        assert_eq!(simd_ge(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([!0, !0, 0, !0]));
+        assert_eq!(simd_gt(a, simd_mul(f128x4::splat(5.0), b)), i32x4::from_array([!0, 0, 0, !0]));
+
+        assert_eq!(simd_reduce_add_ordered(a, 0.0), 40.0f128);
+        assert_eq!(simd_reduce_add_ordered(b, 0.0), 2.0f128);
+        assert_eq!(simd_reduce_mul_ordered(a, 1.0), 10000.0f128);
+        assert_eq!(simd_reduce_mul_ordered(b, 1.0), -24.0f128);
+        assert_eq!(simd_reduce_max(a), 10.0f128);
+        assert_eq!(simd_reduce_max(b), 3.0f128);
+        assert_eq!(simd_reduce_min(a), 10.0f128);
+        assert_eq!(simd_reduce_min(b), -4.0f128);
+
+        assert_eq!(
+            simd_fmax(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
+            f128x2::from_array([0.0, 0.0])
+        );
+        assert_eq!(simd_reduce_max(f128x2::from_array([0.0, f128::NAN])), 0.0f128);
+        assert_eq!(simd_reduce_max(f128x2::from_array([f128::NAN, 0.0])), 0.0f128);
+        assert_eq!(
+            simd_fmin(f128x2::from_array([0.0, f128::NAN]), f128x2::from_array([f128::NAN, 0.0])),
+            f128x2::from_array([0.0, 0.0])
+        );
+        assert_eq!(simd_reduce_min(f128x2::from_array([0.0, f128::NAN])), 0.0f128);
+        assert_eq!(simd_reduce_min(f128x2::from_array([f128::NAN, 0.0])), 0.0f128);
+    }
+}
+
 fn simd_ops_i32() {
     let a = i32x4::splat(10);
     let b = i32x4::from_array([1, 2, 3, -4]);
@@ -563,6 +769,31 @@ fn simd_gather_scatter() {
 }
 
 fn simd_round() {
+    unsafe {
+        use intrinsics::*;
+
+        assert_eq!(
+            simd_ceil(f16x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f16x4::from_array([1.0, 2.0, 2.0, -4.0])
+        );
+        assert_eq!(
+            simd_floor(f16x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f16x4::from_array([0.0, 1.0, 2.0, -5.0])
+        );
+        assert_eq!(
+            simd_round(f16x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f16x4::from_array([1.0, 1.0, 2.0, -5.0])
+        );
+        assert_eq!(
+            simd_round_ties_even(f16x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f16x4::from_array([1.0, 1.0, 2.0, -4.0])
+        );
+        assert_eq!(
+            simd_trunc(f16x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f16x4::from_array([0.0, 1.0, 2.0, -4.0])
+        );
+    }
+
     assert_eq!(
         f32x4::from_array([0.9, 1.001, 2.0, -4.5]).ceil(),
         f32x4::from_array([1.0, 2.0, 2.0, -4.0])
@@ -604,6 +835,31 @@ fn simd_round() {
         f64x4::from_array([0.9, 1.001, 2.0, -4.5]).trunc(),
         f64x4::from_array([0.0, 1.0, 2.0, -4.0])
     );
+
+    unsafe {
+        use intrinsics::*;
+
+        assert_eq!(
+            simd_ceil(f128x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f128x4::from_array([1.0, 2.0, 2.0, -4.0])
+        );
+        assert_eq!(
+            simd_floor(f128x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f128x4::from_array([0.0, 1.0, 2.0, -5.0])
+        );
+        assert_eq!(
+            simd_round(f128x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f128x4::from_array([1.0, 1.0, 2.0, -5.0])
+        );
+        assert_eq!(
+            simd_round_ties_even(f128x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f128x4::from_array([1.0, 1.0, 2.0, -4.0])
+        );
+        assert_eq!(
+            simd_trunc(f128x4::from_array([0.9, 1.001, 2.0, -4.5])),
+            f128x4::from_array([0.0, 1.0, 2.0, -4.0])
+        );
+    }
 }
 
 fn simd_intrinsics() {
@@ -724,8 +980,10 @@ fn simd_ops_non_pow2() {
 
 fn main() {
     simd_mask();
+    simd_ops_f16();
     simd_ops_f32();
     simd_ops_f64();
+    simd_ops_f128();
     simd_ops_i32();
     simd_ops_non_pow2();
     simd_cast();

Original file line number	Diff line number	Diff line change
`@@ -1347,8 +1347,8 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {`
`1347`	`1347`	`}`
`1348`	`1348`
`1349`	`1349`	`#[inline(always)]`
`1350`		`- fn float_fuse_mul_add(ecx: &mut InterpCx<'tcx, Self>) -> bool {`
`1351`		`- ecx.machine.float_nondet && ecx.machine.rng.get_mut().random()`
	`1350`	`+ fn float_fuse_mul_add(ecx: &InterpCx<'tcx, Self>) -> bool {`
	`1351`	`+ ecx.machine.float_nondet && ecx.machine.rng.borrow_mut().random()`
`1352`	`1352`	`}`
`1353`	`1353`
`1354`	`1354`	`#[inline(always)]`