Update experimental threading warning

2022-05-25 21:54:30 +01:00 · 2022-05-25 21:54:30 +01:00 · 6a73dedb36
commit 6a73dedb36
parent bfa56454e9
66 changed files with 165 additions and 61 deletions
--- a/src/shims/unix/thread.rs
+++ b/src/shims/unix/thread.rs
@ -14,7 +14,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
        let this = self.eval_context_mut();

        this.tcx.sess.warn(
-            "thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.",
+            "thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.\n(see https://github.com/rust-lang/miri/issues/1388)",
        );

        // Create the new thread
--- a/tests/compile-fail/weak_memory/cpp20_rwc_syncs.stderr
+++ b/tests/compile-fail/weak_memory/cpp20_rwc_syncs.stderr
@ -0,0 +1,23 @@
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)
+
+error: Undefined Behavior: type validation failed at .value: encountered uninitialized raw pointer
+  --> $DIR/cpp20_rwc_syncs.rs:LL:CC
+   |
+LL |         let _ = unsafe { std::mem::MaybeUninit::<*const u32>::uninit().assume_init() };
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .value: encountered uninitialized raw pointer
+   |
+   = 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: inside `test_cpp20_rwc_syncs` at $DIR/cpp20_rwc_syncs.rs:LL:CC
+note: inside `main` at $DIR/cpp20_rwc_syncs.rs:LL:CC
+  --> $DIR/cpp20_rwc_syncs.rs:LL:CC
+   |
+LL |         test_cpp20_rwc_syncs();
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to previous error; 1 warning emitted
+
--- a/tests/compile-fail/weak_memory/racing_mixed_size.rs
+++ b/tests/compile-fail/weak_memory/racing_mixed_size.rs
@ -1,3 +1,4 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
 // compile-flags: -Zmiri-ignore-leaks

 #![feature(core_intrinsics)]
--- a/tests/compile-fail/weak_memory/racing_mixed_size.stderr
+++ b/tests/compile-fail/weak_memory/racing_mixed_size.stderr
@ -0,0 +1,18 @@
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)
+
+error: Undefined Behavior: racy imperfectly overlapping atomic access
+  --> $DIR/racing_mixed_size.rs:LL:CC
+   |
+LL |             std::intrinsics::atomic_load_relaxed(hi);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ racy imperfectly overlapping atomic access
+   |
+   = 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: inside closure at $DIR/racing_mixed_size.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to previous error; 1 warning emitted
+
--- a/tests/fail/concurrency/libc_pthread_create_main_terminate.stderr
+++ b/tests/fail/concurrency/libc_pthread_create_main_terminate.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: the main thread terminated without waiting for all remaining threads

--- a/tests/fail/concurrency/libc_pthread_join_detached.stderr
+++ b/tests/fail/concurrency/libc_pthread_join_detached.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: trying to join a detached or already joined thread
  --> $DIR/libc_pthread_join_detached.rs:LL:CC
--- a/tests/fail/concurrency/libc_pthread_join_joined.stderr
+++ b/tests/fail/concurrency/libc_pthread_join_joined.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: trying to join a detached or already joined thread
  --> $DIR/libc_pthread_join_joined.rs:LL:CC
--- a/tests/fail/concurrency/libc_pthread_join_main.stderr
+++ b/tests/fail/concurrency/libc_pthread_join_main.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: trying to join a detached or already joined thread
  --> $DIR/libc_pthread_join_main.rs:LL:CC
--- a/tests/fail/concurrency/libc_pthread_join_multiple.stderr
+++ b/tests/fail/concurrency/libc_pthread_join_multiple.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: trying to join a detached or already joined thread
  --> $DIR/libc_pthread_join_multiple.rs:LL:CC
--- a/tests/fail/concurrency/libc_pthread_join_self.stderr
+++ b/tests/fail/concurrency/libc_pthread_join_self.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: trying to join itself
  --> $DIR/libc_pthread_join_self.rs:LL:CC
--- a/tests/fail/concurrency/thread_local_static_dealloc.stderr
+++ b/tests/fail/concurrency/thread_local_static_dealloc.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: pointer to ALLOC was dereferenced after this allocation got freed
  --> $DIR/thread_local_static_dealloc.rs:LL:CC
--- a/tests/fail/concurrency/too_few_args.stderr
+++ b/tests/fail/concurrency/too_few_args.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: callee has fewer arguments than expected
  --> $DIR/too_few_args.rs:LL:CC
--- a/tests/fail/concurrency/too_many_args.stderr
+++ b/tests/fail/concurrency/too_many_args.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: callee has more arguments than expected
  --> $DIR/too_many_args.rs:LL:CC
--- a/tests/fail/concurrency/unwind_top_of_stack.stderr
+++ b/tests/fail/concurrency/unwind_top_of_stack.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 thread '<unnamed>' panicked at 'explicit panic', $DIR/unwind_top_of_stack.rs:LL:CC
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
--- a/tests/fail/data_race/alloc_read_race.stderr
+++ b/tests/fail/data_race/alloc_read_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Read on Thread(id = 2) and Allocate on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/alloc_read_race.rs:LL:CC
--- a/tests/fail/data_race/alloc_write_race.stderr
+++ b/tests/fail/data_race/alloc_write_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 2) and Allocate on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/alloc_write_race.rs:LL:CC
--- a/tests/fail/data_race/atomic_read_na_write_race1.stderr
+++ b/tests/fail/data_race/atomic_read_na_write_race1.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Atomic Load on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/atomic_read_na_write_race1.rs:LL:CC
--- a/tests/fail/data_race/atomic_read_na_write_race2.stderr
+++ b/tests/fail/data_race/atomic_read_na_write_race2.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 2) and Atomic Load on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/atomic_read_na_write_race2.rs:LL:CC
--- a/tests/fail/data_race/atomic_write_na_read_race1.stderr
+++ b/tests/fail/data_race/atomic_write_na_read_race1.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Read on Thread(id = 2) and Atomic Store on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/atomic_write_na_read_race1.rs:LL:CC
--- a/tests/fail/data_race/atomic_write_na_read_race2.stderr
+++ b/tests/fail/data_race/atomic_write_na_read_race2.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Atomic Store on Thread(id = 2) and Read on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/atomic_write_na_read_race2.rs:LL:CC
--- a/tests/fail/data_race/atomic_write_na_write_race1.stderr
+++ b/tests/fail/data_race/atomic_write_na_write_race1.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Atomic Store on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/atomic_write_na_write_race1.rs:LL:CC
--- a/tests/fail/data_race/atomic_write_na_write_race2.stderr
+++ b/tests/fail/data_race/atomic_write_na_write_race2.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 2) and Atomic Store on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/atomic_write_na_write_race2.rs:LL:CC
--- a/tests/fail/data_race/dangling_thread_async_race.stderr
+++ b/tests/fail/data_race/dangling_thread_async_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 3) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/dangling_thread_async_race.rs:LL:CC
--- a/tests/fail/data_race/dangling_thread_race.stderr
+++ b/tests/fail/data_race/dangling_thread_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 0, name = "main") and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/dangling_thread_race.rs:LL:CC
--- a/tests/fail/data_race/dealloc_read_race1.stderr
+++ b/tests/fail/data_race/dealloc_read_race1.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Deallocate on Thread(id = 2) and Read on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/dealloc_read_race1.rs:LL:CC
--- a/tests/fail/data_race/dealloc_read_race2.stderr
+++ b/tests/fail/data_race/dealloc_read_race2.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: pointer to ALLOC was dereferenced after this allocation got freed
  --> $DIR/dealloc_read_race2.rs:LL:CC
--- a/tests/fail/data_race/dealloc_read_race_stack.stderr
+++ b/tests/fail/data_race/dealloc_read_race_stack.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Deallocate on Thread(id = 1) and Read on Thread(id = 2) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/dealloc_read_race_stack.rs:LL:CC
--- a/tests/fail/data_race/dealloc_write_race1.stderr
+++ b/tests/fail/data_race/dealloc_write_race1.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Deallocate on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/dealloc_write_race1.rs:LL:CC
--- a/tests/fail/data_race/dealloc_write_race2.stderr
+++ b/tests/fail/data_race/dealloc_write_race2.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: pointer to ALLOC was dereferenced after this allocation got freed
  --> $DIR/dealloc_write_race2.rs:LL:CC
--- a/tests/fail/data_race/dealloc_write_race_stack.stderr
+++ b/tests/fail/data_race/dealloc_write_race_stack.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Deallocate on Thread(id = 1) and Write on Thread(id = 2) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/dealloc_write_race_stack.rs:LL:CC
--- a/tests/fail/data_race/enable_after_join_to_main.stderr
+++ b/tests/fail/data_race/enable_after_join_to_main.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 6) and Write on Thread(id = 5) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/enable_after_join_to_main.rs:LL:CC
--- a/tests/fail/data_race/fence_after_load.stderr
+++ b/tests/fail/data_race/fence_after_load.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 0, name = "main") and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/fence_after_load.rs:LL:CC
--- a/tests/fail/data_race/read_write_race.stderr
+++ b/tests/fail/data_race/read_write_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 2) and Read on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/read_write_race.rs:LL:CC
--- a/tests/fail/data_race/read_write_race_stack.stderr
+++ b/tests/fail/data_race/read_write_race_stack.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Read on Thread(id = 1) and Write on Thread(id = 2) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/read_write_race_stack.rs:LL:CC
--- a/tests/fail/data_race/relax_acquire_race.stderr
+++ b/tests/fail/data_race/relax_acquire_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Read on Thread(id = 3) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/relax_acquire_race.rs:LL:CC
--- a/tests/fail/data_race/release_seq_race.stderr
+++ b/tests/fail/data_race/release_seq_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Read on Thread(id = 3) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/release_seq_race.rs:LL:CC
--- a/tests/fail/data_race/release_seq_race_same_thread.stderr
+++ b/tests/fail/data_race/release_seq_race_same_thread.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Read on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/release_seq_race_same_thread.rs:LL:CC
--- a/tests/fail/data_race/rmw_race.stderr
+++ b/tests/fail/data_race/rmw_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Read on Thread(id = 3) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/rmw_race.rs:LL:CC
--- a/tests/fail/data_race/write_write_race.stderr
+++ b/tests/fail/data_race/write_write_race.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 2) and Write on Thread(id = 1) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/write_write_race.rs:LL:CC
--- a/tests/fail/data_race/write_write_race_stack.stderr
+++ b/tests/fail/data_race/write_write_race_stack.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: Data race detected between Write on Thread(id = 1) and Write on Thread(id = 2) at ALLOC (current vector clock = VClock, conflicting timestamp = VClock)
  --> $DIR/write_write_race_stack.rs:LL:CC
--- a/tests/fail/sync/libc_pthread_mutex_deadlock.stderr
+++ b/tests/fail/sync/libc_pthread_mutex_deadlock.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: deadlock: the evaluated program deadlocked
  --> $DIR/libc_pthread_mutex_deadlock.rs:LL:CC
--- a/tests/fail/sync/libc_pthread_mutex_wrong_owner.stderr
+++ b/tests/fail/sync/libc_pthread_mutex_wrong_owner.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: unlocked a default mutex that was not locked by the current thread
  --> $DIR/libc_pthread_mutex_wrong_owner.rs:LL:CC
--- a/tests/fail/sync/libc_pthread_rwlock_read_wrong_owner.stderr
+++ b/tests/fail/sync/libc_pthread_rwlock_read_wrong_owner.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: unlocked an rwlock that was not locked by the active thread
  --> $DIR/libc_pthread_rwlock_read_wrong_owner.rs:LL:CC
--- a/tests/fail/sync/libc_pthread_rwlock_write_read_deadlock.stderr
+++ b/tests/fail/sync/libc_pthread_rwlock_write_read_deadlock.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: deadlock: the evaluated program deadlocked
  --> $DIR/libc_pthread_rwlock_write_read_deadlock.rs:LL:CC
--- a/tests/fail/sync/libc_pthread_rwlock_write_write_deadlock.stderr
+++ b/tests/fail/sync/libc_pthread_rwlock_write_write_deadlock.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: deadlock: the evaluated program deadlocked
  --> $DIR/libc_pthread_rwlock_write_write_deadlock.rs:LL:CC
--- a/tests/fail/sync/libc_pthread_rwlock_write_wrong_owner.stderr
+++ b/tests/fail/sync/libc_pthread_rwlock_write_wrong_owner.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 error: Undefined Behavior: unlocked an rwlock that was not locked by the active thread
  --> $DIR/libc_pthread_rwlock_write_wrong_owner.rs:LL:CC
--- a/tests/pass/concurrency/channels.stderr
+++ b/tests/pass/concurrency/channels.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/concurrent_caller_location.stderr
+++ b/tests/pass/concurrency/concurrent_caller_location.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/data_race.stderr
+++ b/tests/pass/concurrency/data_race.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/disable_data_race_detector.stderr
+++ b/tests/pass/concurrency/disable_data_race_detector.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/issue1643.stderr
+++ b/tests/pass/concurrency/issue1643.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/linux-futex.stderr
+++ b/tests/pass/concurrency/linux-futex.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/simple.stderr
+++ b/tests/pass/concurrency/simple.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 thread '<unnamed>' panicked at 'Hello!', $DIR/simple.rs:LL:CC
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
--- a/tests/pass/concurrency/spin_loops.stderr
+++ b/tests/pass/concurrency/spin_loops.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental and incomplete: weak memory effects are not emulated.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/sync.stderr
+++ b/tests/pass/concurrency/sync.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/thread_locals.stderr
+++ b/tests/pass/concurrency/thread_locals.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/concurrency/tls_lib_drop.stderr
+++ b/tests/pass/concurrency/tls_lib_drop.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/libc.stderr
+++ b/tests/pass/libc.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/pass/panic/concurrent-panic.stderr
+++ b/tests/pass/panic/concurrent-panic.stderr
@ -1,4 +1,5 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 Thread 1 starting, will block on mutex
 Thread 1 reported it has started
--- a/tests/pass/threadleak_ignored.stderr
+++ b/tests/pass/threadleak_ignored.stderr
@ -1,3 +1,4 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

 Dropping 0
--- a/tests/run-pass/weak_memory/consistency.stderr
+++ b/tests/run-pass/weak_memory/consistency.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/run-pass/weak_memory/extra_cpp.rs
+++ b/tests/run-pass/weak_memory/extra_cpp.rs
@ -1,3 +1,4 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
 // compile-flags: -Zmiri-ignore-leaks

 // Tests operations not perfomable through C++'s atomic API
--- a/tests/run-pass/weak_memory/extra_cpp.stderr
+++ b/tests/run-pass/weak_memory/extra_cpp.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/run-pass/weak_memory/extra_cpp_unsafe.rs
+++ b/tests/run-pass/weak_memory/extra_cpp_unsafe.rs
@ -1,3 +1,4 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
 // compile-flags: -Zmiri-ignore-leaks

 // Tests operations not perfomable through C++'s atomic API
--- a/tests/run-pass/weak_memory/extra_cpp_unsafe.stderr
+++ b/tests/run-pass/weak_memory/extra_cpp_unsafe.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)

--- a/tests/run-pass/weak_memory/weak.stderr
+++ b/tests/run-pass/weak_memory/weak.stderr
@ -1,2 +1,3 @@
-warning: thread support is experimental: weak memory effects are not fully compatible with the Rust atomics memory model.
+warning: thread support is experimental: the scheduler is not preemptive, and can get stuck in spin loops.
+         (see https://github.com/rust-lang/miri/issues/1388)