Factor out sc_read and sc_writes

Author: cbeuw

src/data_race.rs

@@ -481,16 +481,14 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
         // the *value* (including the associated provenance if this is an AtomicPtr) at this location.
         // Only metadata on the location itself is used.
         let scalar = this.allow_data_races_ref(move |this| this.read_scalar(&place.into()))?;
-        if atomic == AtomicReadOp::SeqCst {
-            if let Some(global) = &this.memory.extra.data_race {
-                global.sc_read();
-            }
-        }
 
         if let Some(global) = &this.memory.extra.data_race {
             let (alloc_id, base_offset, ..) = this.memory.ptr_get_alloc(place.ptr)?;
             if let Some(alloc_buffers) = this.memory.get_alloc_extra(alloc_id)?.weak_memory.as_ref()
             {
+                if atomic == AtomicReadOp::SeqCst {
+                    global.sc_read();
+                }
                 let mut rng = this.memory.extra.rng.borrow_mut();
                 let loaded = alloc_buffers.buffered_read(
                     alloc_range(base_offset, place.layout.size),
@@ -518,19 +516,16 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
         let this = self.eval_context_mut();
         this.allow_data_races_mut(move |this| this.write_scalar(val, &(*dest).into()))?;
 
-        if atomic == AtomicWriteOp::SeqCst {
-            if let Some(global) = this.memory.extra.data_race.as_ref() {
-                global.sc_write();
-            }
-        }
-
         this.validate_atomic_store(dest, atomic)?;
         let (alloc_id, base_offset, ..) = this.memory.ptr_get_alloc(dest.ptr)?;
         if let (
             crate::AllocExtra { weak_memory: Some(alloc_buffers), .. },
             crate::MemoryExtra { data_race: Some(global), .. },
         ) = this.memory.get_alloc_extra_mut(alloc_id)?
         {
+            if atomic == AtomicWriteOp::SeqCst {
+                global.sc_write();
+            }
             let size = dest.layout.size;
             alloc_buffers.buffered_write(
                 val,
@@ -561,12 +556,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
         let val = if neg { this.unary_op(mir::UnOp::Not, &val)? } else { val };
         this.allow_data_races_mut(|this| this.write_immediate(*val, &(*place).into()))?;
 
-        if atomic == AtomicRwOp::SeqCst {
-            if let Some(global) = &this.memory.extra.data_race {
-                global.sc_read();
-                global.sc_write();
-            }
-        }
         this.validate_atomic_rmw(place, atomic)?;
 
         this.buffered_atomic_rmw(val.to_scalar_or_uninit(), place, atomic)?;
@@ -585,12 +574,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
 
         let old = this.allow_data_races_mut(|this| this.read_scalar(&place.into()))?;
         this.allow_data_races_mut(|this| this.write_scalar(new, &(*place).into()))?;
-        if atomic == AtomicRwOp::SeqCst {
-            if let Some(global) = &this.memory.extra.data_race {
-                global.sc_read();
-                global.sc_write();
-            }
-        }
+
         this.validate_atomic_rmw(place, atomic)?;
 
         this.buffered_atomic_rmw(new, place, atomic)?;
@@ -619,12 +603,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
 
         this.allow_data_races_mut(|this| this.write_immediate(**new_val, &(*place).into()))?;
 
-        if atomic == AtomicRwOp::SeqCst {
-            if let Some(global) = &this.memory.extra.data_race {
-                global.sc_read();
-                global.sc_write();
-            }
-        }
         this.validate_atomic_rmw(&place, atomic)?;
 
         this.buffered_atomic_rmw(new_val.to_scalar_or_uninit(), place, atomic)?;
@@ -673,27 +651,18 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
         // otherwise treat this as an atomic load with the fail ordering.
         if cmpxchg_success {
             this.allow_data_races_mut(|this| this.write_scalar(new, &(*place).into()))?;
-            if success == AtomicRwOp::SeqCst {
-                if let Some(global) = &this.memory.extra.data_race {
-                    global.sc_read();
-                    global.sc_write();
-                }
-            }
             this.validate_atomic_rmw(place, success)?;
             this.buffered_atomic_rmw(new, place, success)?;
         } else {
-            if fail == AtomicReadOp::SeqCst {
-                if let Some(global) = &this.memory.extra.data_race {
-                    global.sc_read();
-                }
-            }
-
             this.validate_atomic_load(place, fail)?;
             // A failed compare exchange is equivalent to a load, reading from the latest store
             // in the modification order.
             // Since `old` is only a value and not the store element, we need to separately
             // find it in our store buffer and perform load_impl on it.
             if let Some(global) = &this.memory.extra.data_race {
+                if fail == AtomicReadOp::SeqCst {
+                    global.sc_read();
+                }
                 let size = place.layout.size;
                 let (alloc_id, base_offset, ..) = this.memory.ptr_get_alloc(place.ptr)?;
                 if let Some(alloc_buffers) =
@@ -723,6 +692,10 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
             crate::MemoryExtra { data_race: Some(global), .. },
         ) = this.memory.get_alloc_extra_mut(alloc_id)?
         {
+            if atomic == AtomicRwOp::SeqCst {
+                global.sc_read();
+                global.sc_write();
+            }
             let size = place.layout.size;
             let range = alloc_range(base_offset, size);
             alloc_buffers.read_from_last_store(range, global);