Detect races between atomic and non-atomic accesses of a variable,

 previously only data races between two non-atomic accesses were
 detected.

Author: JCTyblaidd

src/data_race.rs

@@ -78,7 +78,10 @@ pub fn futex<'tcx>(
             // Read an `i32` through the pointer, regardless of any wrapper types.
             // It's not uncommon for `addr` to be passed as another type than `*mut i32`, such as `*const AtomicI32`.
             // FIXME: this fails if `addr` is not a pointer type.
-            let futex_val = this.read_scalar_at_offset(addr.into(), 0, this.machine.layouts.i32)?.to_i32()?;
+            // FIXME: what form of atomic operation should the `futex` use to load the value?
+            let futex_val = this.read_scalar_at_offset_atomic(
+                addr.into(), 0, this.machine.layouts.i32, AtomicReadOp::Acquire
+            )?.to_i32()?;
             if val == futex_val {
                 // The value still matches, so we block the trait make it wait for FUTEX_WAKE.
                 this.block_thread(thread);

src/shims/posix/linux/sync.rs

@@ -0,0 +1,31 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
+#![feature(core_intrinsics)]
+
+use std::thread::spawn;
+use std::sync::atomic::AtomicUsize;
+use std::intrinsics::atomic_load;
+
+#[derive(Copy, Clone)]
+struct EvilSend<T>(pub T);
+
+unsafe impl<T> Send for EvilSend<T> {}
+unsafe impl<T> Sync for EvilSend<T> {}
+
+pub fn main() {
+    let mut a = AtomicUsize::new(0);
+    let b = &mut a as *mut AtomicUsize;
+    let c = EvilSend(b);
+    unsafe {
+        let j1 = spawn(move || {
+            *(c.0 as *mut usize) = 32;
+        });
+
+        let j2 = spawn(move || {
+            //Equivalent to: (&*c.0).load(Ordering::SeqCst)
+            atomic_load(c.0 as *mut usize) //~ ERROR Data race
+        });
+
+        j1.join().unwrap();
+        j2.join().unwrap();
+    }
+}

tests/compile-fail/data_race/atomic_read_write_race.rs

@@ -0,0 +1,31 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
+
+use std::thread::spawn;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+
+#[derive(Copy, Clone)]
+struct EvilSend<T>(pub T);
+
+unsafe impl<T> Send for EvilSend<T> {}
+unsafe impl<T> Sync for EvilSend<T> {}
+
+pub fn main() {
+    let mut a = AtomicUsize::new(0);
+    let b = &mut a as *mut AtomicUsize;
+    let c = EvilSend(b);
+    unsafe {
+        let j1 = spawn(move || {
+            let atomic_ref = &mut *c.0;
+            atomic_ref.load(Ordering::SeqCst)
+        });
+
+        let j2 = spawn(move || {
+            let atomic_ref = &mut *c.0;
+            *atomic_ref.get_mut() = 32; //~ ERROR Data race
+        });
+
+        j1.join().unwrap();
+        j2.join().unwrap();
+    }
+}

tests/compile-fail/data_race/atomic_read_write_race_alt.rs

@@ -0,0 +1,31 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
+
+use std::thread::spawn;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+
+#[derive(Copy, Clone)]
+struct EvilSend<T>(pub T);
+
+unsafe impl<T> Send for EvilSend<T> {}
+unsafe impl<T> Sync for EvilSend<T> {}
+
+pub fn main() {
+    let mut a = AtomicUsize::new(0);
+    let b = &mut a as *mut AtomicUsize;
+    let c = EvilSend(b);
+    unsafe {
+        let j1 = spawn(move || {
+            let atomic_ref = &mut *c.0;
+            atomic_ref.store(32, Ordering::SeqCst)
+        });
+
+        let j2 = spawn(move || {
+            let atomic_ref = &mut *c.0;
+            *atomic_ref.get_mut() //~ ERROR Data race
+        });
+
+        j1.join().unwrap();
+        j2.join().unwrap();
+    }
+}

tests/compile-fail/data_race/atomic_write_read_race.rs

@@ -0,0 +1,31 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
+#![feature(core_intrinsics)]
+
+use std::thread::spawn;
+use std::sync::atomic::AtomicUsize;
+use std::intrinsics::atomic_store;
+
+#[derive(Copy, Clone)]
+struct EvilSend<T>(pub T);
+
+unsafe impl<T> Send for EvilSend<T> {}
+unsafe impl<T> Sync for EvilSend<T> {}
+
+pub fn main() {
+    let mut a = AtomicUsize::new(0);
+    let b = &mut a as *mut AtomicUsize;
+    let c = EvilSend(b);
+    unsafe {
+        let j1 = spawn(move || {
+            *(c.0 as *mut usize)
+        });
+
+        let j2 = spawn(move || {
+            //Equivalent to: (&*c.0).store(32, Ordering::SeqCst)
+            atomic_store(c.0 as *mut usize, 32); //~ ERROR Data race
+        });
+
+        j1.join().unwrap();
+        j2.join().unwrap();
+    }
+}

tests/compile-fail/data_race/atomic_write_read_race_alt.rs

@@ -0,0 +1,31 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
+#![feature(core_intrinsics)]
+
+use std::thread::spawn;
+use std::sync::atomic::AtomicUsize;
+use std::intrinsics::atomic_store;
+
+#[derive(Copy, Clone)]
+struct EvilSend<T>(pub T);
+
+unsafe impl<T> Send for EvilSend<T> {}
+unsafe impl<T> Sync for EvilSend<T> {}
+
+pub fn main() {
+    let mut a = AtomicUsize::new(0);
+    let b = &mut a as *mut AtomicUsize;
+    let c = EvilSend(b);
+    unsafe {
+        let j1 = spawn(move || {
+            *(c.0 as *mut usize) = 32;
+        });
+
+        let j2 = spawn(move || {
+            //Equivalent to: (&*c.0).store(64, Ordering::SeqCst)
+            atomic_store(c.0 as *mut usize, 64); //~ ERROR Data race
+        });
+
+        j1.join().unwrap();
+        j2.join().unwrap();
+    }
+}

tests/compile-fail/data_race/atomic_write_write_race.rs

@@ -0,0 +1,31 @@
+// ignore-windows: Concurrency on Windows is not supported yet.
+
+use std::thread::spawn;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+
+#[derive(Copy, Clone)]
+struct EvilSend<T>(pub T);
+
+unsafe impl<T> Send for EvilSend<T> {}
+unsafe impl<T> Sync for EvilSend<T> {}
+
+pub fn main() {
+    let mut a = AtomicUsize::new(0);
+    let b = &mut a as *mut AtomicUsize;
+    let c = EvilSend(b);
+    unsafe {
+        let j1 = spawn(move || {
+            let atomic_ref = &mut *c.0;
+            atomic_ref.store(64, Ordering::SeqCst);
+        });
+
+        let j2 = spawn(move || {
+            let atomic_ref = &mut *c.0;
+            *atomic_ref.get_mut() = 32; //~ ERROR Data race
+        });
+
+        j1.join().unwrap();
+        j2.join().unwrap();
+    }
+}