Auto merge of #148425 - matthiaskrgr:rollup-pwibmxt, r=matthiaskrgr

Rollup of 3 pull requests

Successful merges:

 - rust-lang/rust#146260 (add SliceIndex wrapper types Last and Clamp<Idx>)
 - rust-lang/rust#148394 (Make explicit that `TypeId`'s layout and size are unstable)
 - rust-lang/rust#148402 (stdarch subtree update)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

src/shims/x86/avx.rs

@@ -217,50 +217,6 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     )?;
                 }
             }
-            // Used to implement the _mm256_permute2f128_ps, _mm256_permute2f128_pd and
-            // _mm256_permute2f128_si256 functions. Regardless of the suffix in the name
-            // thay all can be considered to operate on vectors of 128-bit elements.
-            // For each 128-bit element of `dest`, copies one from `left`, `right` or
-            // zero, according to `imm`.
-            "vperm2f128.ps.256" | "vperm2f128.pd.256" | "vperm2f128.si.256" => {
-                let [left, right, imm] =
-                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
-
-                assert_eq!(dest.layout, left.layout);
-                assert_eq!(dest.layout, right.layout);
-                assert_eq!(dest.layout.size.bits(), 256);
-
-                // Transmute to `[u128; 2]` to process each 128-bit chunk independently.
-                let u128x2_layout =
-                    this.layout_of(Ty::new_array(this.tcx.tcx, this.tcx.types.u128, 2))?;
-                let left = left.transmute(u128x2_layout, this)?;
-                let right = right.transmute(u128x2_layout, this)?;
-                let dest = dest.transmute(u128x2_layout, this)?;
-
-                let imm = this.read_scalar(imm)?.to_u8()?;
-
-                for i in 0..2 {
-                    let dest = this.project_index(&dest, i)?;
-
-                    let imm = match i {
-                        0 => imm & 0xF,
-                        1 => imm >> 4,
-                        _ => unreachable!(),
-                    };
-                    if imm & 0b100 != 0 {
-                        this.write_scalar(Scalar::from_u128(0), &dest)?;
-                    } else {
-                        let src = match imm {
-                            0b00 => this.project_index(&left, 0)?,
-                            0b01 => this.project_index(&left, 1)?,
-                            0b10 => this.project_index(&right, 0)?,
-                            0b11 => this.project_index(&right, 1)?,
-                            _ => unreachable!(),
-                        };
-                        this.copy_op(&src, &dest)?;
-                    }
-                }
-            }
             // Used to implement the _mm_maskload_ps, _mm_maskload_pd, _mm256_maskload_ps
             // and _mm256_maskload_pd functions.
             // For the element `i`, if the high bit of the `i`-th element of `mask`

tests/pass/shims/x86/intrinsics-x86-avx.rs

@@ -829,41 +829,44 @@ unsafe fn test_avx() {
 
     #[target_feature(enable = "avx")]
     unsafe fn test_mm256_permute2f128_ps() {
-        let a = _mm256_setr_ps(1., 2., 3., 4., 1., 2., 3., 4.);
-        let b = _mm256_setr_ps(5., 6., 7., 8., 5., 6., 7., 8.);
-        let r = _mm256_permute2f128_ps::<0x13>(a, b);
-        let e = _mm256_setr_ps(5., 6., 7., 8., 1., 2., 3., 4.);
+        let a = _mm256_setr_ps(11., 12., 13., 14., 15., 16., 17., 18.);
+        let b = _mm256_setr_ps(21., 22., 23., 24., 25., 26., 27., 28.);
+        let r = _mm256_permute2f128_ps::<0b0001_0011>(a, b);
+        let e = _mm256_setr_ps(25., 26., 27., 28., 15., 16., 17., 18.);
         assert_eq_m256(r, e);
 
-        let r = _mm256_permute2f128_ps::<0x44>(a, b);
-        let e = _mm256_setr_ps(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-        assert_eq_m256(r, e);
+        // Setting bits 3 or 7 (zero-indexed) zeroes the corresponding field.
+        let r = _mm256_permute2f128_ps::<0b1001_1011>(a, b);
+        let z = _mm256_setr_ps(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+        assert_eq_m256(r, z);
     }
     test_mm256_permute2f128_ps();
 
     #[target_feature(enable = "avx")]
     unsafe fn test_mm256_permute2f128_pd() {
         let a = _mm256_setr_pd(1., 2., 3., 4.);
         let b = _mm256_setr_pd(5., 6., 7., 8.);
-        let r = _mm256_permute2f128_pd::<0x31>(a, b);
+        let r = _mm256_permute2f128_pd::<0b0011_0001>(a, b);
         let e = _mm256_setr_pd(3., 4., 7., 8.);
         assert_eq_m256d(r, e);
 
-        let r = _mm256_permute2f128_pd::<0x44>(a, b);
+        // Setting bits 3 or 7 (zero-indexed) zeroes the corresponding field.
+        let r = _mm256_permute2f128_pd::<0b1011_1001>(a, b);
         let e = _mm256_setr_pd(0.0, 0.0, 0.0, 0.0);
         assert_eq_m256d(r, e);
     }
     test_mm256_permute2f128_pd();
 
     #[target_feature(enable = "avx")]
     unsafe fn test_mm256_permute2f128_si256() {
-        let a = _mm256_setr_epi32(1, 2, 3, 4, 1, 2, 3, 4);
-        let b = _mm256_setr_epi32(5, 6, 7, 8, 5, 6, 7, 8);
-        let r = _mm256_permute2f128_si256::<0x20>(a, b);
-        let e = _mm256_setr_epi32(1, 2, 3, 4, 5, 6, 7, 8);
+        let a = _mm256_setr_epi32(11, 12, 13, 14, 15, 16, 17, 18);
+        let b = _mm256_setr_epi32(21, 22, 23, 24, 25, 26, 27, 28);
+        let r = _mm256_permute2f128_si256::<0b0010_0000>(a, b);
+        let e = _mm256_setr_epi32(11, 12, 13, 14, 21, 22, 23, 24);
         assert_eq_m256i(r, e);
 
-        let r = _mm256_permute2f128_si256::<0x44>(a, b);
+        // Setting bits 3 or 7 (zero-indexed) zeroes the corresponding field.
+        let r = _mm256_permute2f128_si256::<0b1010_1000>(a, b);
         let e = _mm256_setr_epi32(0, 0, 0, 0, 0, 0, 0, 0);
         assert_eq_m256i(r, e);
     }

tests/pass/shims/x86/intrinsics-x86-pause-without-sse2.rs

@@ -9,10 +9,5 @@ use std::arch::x86_64::*;
 
 fn main() {
     assert!(!is_x86_feature_detected!("sse2"));
-
-    unsafe {
-        // This is a SSE2 intrinsic, but it behaves as a no-op when SSE2
-        // is not available, so it is always safe to call.
-        _mm_pause();
-    }
+    _mm_pause();
 }

tests/pass/shims/x86/intrinsics-x86-sse2.rs

@@ -54,7 +54,7 @@ unsafe fn test_sse2() {
     }
 
     fn test_mm_pause() {
-        unsafe { _mm_pause() }
+        _mm_pause()
     }
     test_mm_pause();
 

tests/pass/shims/x86/intrinsics-x86.rs

@@ -7,17 +7,13 @@ mod x86 {
 
     fn adc(c_in: u8, a: u32, b: u32) -> (u8, u32) {
         let mut sum = 0;
-        // SAFETY: There are no safety requirements for calling `_addcarry_u32`.
-        // It's just unsafe for API consistency with other intrinsics.
-        let c_out = unsafe { arch::_addcarry_u32(c_in, a, b, &mut sum) };
+        let c_out = arch::_addcarry_u32(c_in, a, b, &mut sum);
         (c_out, sum)
     }
 
     fn sbb(b_in: u8, a: u32, b: u32) -> (u8, u32) {
         let mut sum = 0;
-        // SAFETY: There are no safety requirements for calling `_subborrow_u32`.
-        // It's just unsafe for API consistency with other intrinsics.
-        let b_out = unsafe { arch::_subborrow_u32(b_in, a, b, &mut sum) };
+        let b_out = arch::_subborrow_u32(b_in, a, b, &mut sum);
         (b_out, sum)
     }
 
@@ -52,17 +48,13 @@ mod x86_64 {
 
     fn adc(c_in: u8, a: u64, b: u64) -> (u8, u64) {
         let mut sum = 0;
-        // SAFETY: There are no safety requirements for calling `_addcarry_u64`.
-        // It's just unsafe for API consistency with other intrinsics.
-        let c_out = unsafe { arch::_addcarry_u64(c_in, a, b, &mut sum) };
+        let c_out = arch::_addcarry_u64(c_in, a, b, &mut sum);
         (c_out, sum)
     }
 
     fn sbb(b_in: u8, a: u64, b: u64) -> (u8, u64) {
         let mut sum = 0;
-        // SAFETY: There are no safety requirements for calling `_subborrow_u64`.
-        // It's just unsafe for API consistency with other intrinsics.
-        let b_out = unsafe { arch::_subborrow_u64(b_in, a, b, &mut sum) };
+        let b_out = arch::_subborrow_u64(b_in, a, b, &mut sum);
         (b_out, sum)
     }