Auto merge of #3320 - RalfJung:rustup, r=RalfJung

Rustup

Let's see if rust-lang/rust#121114 gets perf back to the old level.

Author: bors

rust-version

@@ -1 +1 @@
-c5f69bdd5173a948e0131f934fa7c4cbf5e0b55f
+a2f3c0cf880ad819c4eab2b320525b6a31ac6513

src/shims/intrinsics/simd.rs

@@ -563,9 +563,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                         let right_idx = src_index.checked_sub(left_len).unwrap();
                         this.read_immediate(&this.project_index(&right, right_idx)?)?
                     } else {
-                        span_bug!(
-                            this.cur_span(),
-                            "simd_shuffle index {src_index} is out of bounds for 2 vectors of size {left_len}",
+                        throw_ub_format!(
+                            "`simd_shuffle_generic` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
                         );
                     };
                     this.write_immediate(*val, &dest)?;
@@ -604,9 +603,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
                         let right_idx = src_index.checked_sub(left_len).unwrap();
                         this.read_immediate(&this.project_index(&right, right_idx)?)?
                     } else {
-                        span_bug!(
-                            this.cur_span(),
-                            "simd_shuffle index {src_index} is out of bounds for 2 vectors of size {left_len}",
+                        throw_ub_format!(
+                            "`simd_shuffle` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
                         );
                     };
                     this.write_immediate(*val, &dest)?;

tests/fail/intrinsics/simd-extract.rs

@@ -0,0 +1,8 @@
+#![feature(portable_simd, core_intrinsics)]
+use std::simd::*;
+
+fn main() {
+    let v = i32x4::splat(0);
+    let _x: i32 = unsafe { std::intrinsics::simd::simd_extract(v, 4) };
+    //~^ERROR: index 4 is out-of-bounds
+}

tests/fail/intrinsics/simd-extract.stderr

@@ -0,0 +1,15 @@
+error: Undefined Behavior: `simd_extract` index 4 is out-of-bounds of vector with length 4
+  --> $DIR/simd-extract.rs:LL:CC
+   |
+LL |     let _x: i32 = unsafe { std::intrinsics::simd::simd_extract(v, 4) };
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `simd_extract` index 4 is out-of-bounds of vector with length 4
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: BACKTRACE:
+   = note: inside `main` at $DIR/simd-extract.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+

tests/fail/tls/tls_static_dealloc.rs

@@ -1,8 +1,8 @@
 //! Ensure that thread-local statics get deallocated when the thread dies.
 
 #![feature(thread_local)]
-// FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_refs` lint
-#![allow(static_mut_refs)]
+
+use std::ptr::addr_of;
 
 #[thread_local]
 static mut TLS: u8 = 0;
@@ -12,7 +12,7 @@ unsafe impl Send for SendRaw {}
 
 fn main() {
     unsafe {
-        let dangling_ptr = std::thread::spawn(|| SendRaw(&TLS as *const u8)).join().unwrap();
+        let dangling_ptr = std::thread::spawn(|| SendRaw(addr_of!(TLS))).join().unwrap();
         let _val = *dangling_ptr.0; //~ ERROR: has been freed
     }
 }

tests/pass/static_mut.rs

@@ -1,8 +1,8 @@
+use std::ptr::addr_of;
+
 static mut FOO: i32 = 42;
 
-// FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_refs` lint
-#[allow(static_mut_refs)]
-static BAR: Foo = Foo(unsafe { &FOO as *const _ });
+static BAR: Foo = Foo(unsafe { addr_of!(FOO) });
 
 #[allow(dead_code)]
 struct Foo(*const i32);

tests/pass/tls/tls_static.rs

@@ -8,9 +8,8 @@
 //! test, we also check that thread-locals act as per-thread statics.
 
 #![feature(thread_local)]
-// FIXME: Use `SyncUnsafeCell` instead of allowing `static_mut_refs` lint
-#![allow(static_mut_refs)]
 
+use std::ptr::addr_of_mut;
 use std::thread;
 
 #[thread_local]
@@ -23,8 +22,8 @@ static mut C: u8 = 0;
 #[thread_local]
 static READ_ONLY: u8 = 42;
 
-unsafe fn get_a_ref() -> *mut u8 {
-    &mut A
+unsafe fn get_a_ptr() -> *mut u8 {
+    addr_of_mut!(A)
 }
 
 struct Sender(*mut u8);
@@ -35,12 +34,12 @@ fn main() {
     let _val = READ_ONLY;
 
     let ptr = unsafe {
-        let x = get_a_ref();
+        let x = get_a_ptr();
         *x = 5;
         assert_eq!(A, 5);
         B = 15;
         C = 25;
-        Sender(&mut A)
+        Sender(addr_of_mut!(A))
     };
 
     thread::spawn(move || unsafe {
@@ -51,18 +50,18 @@ fn main() {
         assert_eq!(C, 25);
         B = 14;
         C = 24;
-        let y = get_a_ref();
+        let y = get_a_ptr();
         assert_eq!(*y, 0);
         *y = 4;
         assert_eq!(*ptr.0, 5);
         assert_eq!(A, 4);
-        assert_eq!(*get_a_ref(), 4);
+        assert_eq!(*get_a_ptr(), 4);
     })
     .join()
     .unwrap();
 
     unsafe {
-        assert_eq!(*get_a_ref(), 5);
+        assert_eq!(*get_a_ptr(), 5);
         assert_eq!(A, 5);
         assert_eq!(B, 15);
         assert_eq!(C, 24);