add test

Author: henryboisdequin

src/data_race.rs

@@ -557,16 +557,16 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: MiriEvalContextExt<'mir, 'tcx> {
 
         // `binary_op` will bail if either of them is not a scalar.
         let cond = if min {
-            this.overflowing_binary_op(mir::BinOp::Lt, old, rhs)?.0
+            this.overflowing_binary_op(mir::BinOp::Lt, &old, &rhs)?.0
         } else {
-            this.overflowing_binary_op(mir::BinOp::Gt, old, rhs)?.0
+            this.overflowing_binary_op(mir::BinOp::Gt, &old, &rhs)?.0
         };
 
         if cond.to_bool()? {
             this.allow_data_races_mut(|this| this.write_immediate(*rhs, place.into()))?;
         }
 
-        this.validate_atomic_rmw(place, atomic)?;
+        this.validate_atomic_rmw(&place, atomic)?;
         // Return the old value.
         Ok(old)
     }

src/shims/intrinsics.rs

@@ -686,18 +686,18 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     fn atomic_min_max(
         &mut self,
         args: &[OpTy<'tcx, Tag>],
-        dest: PlaceTy<'tcx, Tag>,
+        dest: &PlaceTy<'tcx, Tag>,
         min: bool,
         atomic: AtomicRwOp,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
         let &[place, rhs] = check_arg_count(args)?;
-        let place = this.deref_operand(place)?;
+        let place = this.deref_operand(&place)?;
         if !place.layout.ty.is_integral() {
             bug!("Atomic arithmetic operations only work on integer types");
         }
-        let rhs = this.read_immediate(rhs)?;
+        let rhs = this.read_immediate(&rhs)?;
 
         // Check alignment requirements. Atomics must always be aligned to their size,
         // even if the type they wrap would be less aligned (e.g. AtomicU64 on 32bit must
@@ -706,7 +706,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         this.memory.check_ptr_access(place.ptr, place.layout.size, align)?;
 
         let old = this.atomic_min_max_scalar(place, rhs, min, atomic)?;
-        this.write_immediate(*old, dest)?; // old value is returned
+        this.write_immediate(*old, &dest)?; // old value is returned
         Ok(())
     }
 

tests/run-pass/atomic.rs

@@ -74,6 +74,20 @@ fn atomic_u64() {
     assert_eq!(ATOMIC.compare_exchange(0, 0x100, AcqRel, Acquire), Err(1));
     compare_exchange_weak_loop!(ATOMIC, 1, 0x100, AcqRel, Acquire);
     assert_eq!(ATOMIC.load(Relaxed), 0x100);
+
+    assert_eq!(ATOMIC.fetch_max(0x10, SeqCst), 0x100);
+    assert_eq!(ATOMIC.fetch_max(0x100, SeqCst), 0x100);
+    assert_eq!(ATOMIC.fetch_max(0x1000, SeqCst), 0x100);
+    assert_eq!(ATOMIC.fetch_max(0x1000, SeqCst), 0x1000);
+    assert_eq!(ATOMIC.fetch_max(0x2000, SeqCst), 0x1000);
+    assert_eq!(ATOMIC.fetch_max(0x2000, SeqCst), 0x2000);
+
+    assert_eq!(ATOMIC.fetch_min(0x2000, SeqCst), 0x2000);
+    assert_eq!(ATOMIC.fetch_min(0x2000, SeqCst), 0x2000);
+    assert_eq!(ATOMIC.fetch_max(0x1000, SeqCst), 0x2000);
+    assert_eq!(ATOMIC.fetch_max(0x1000, SeqCst), 0x1000);
+    assert_eq!(ATOMIC.fetch_max(0x100, SeqCst), 0x1000);
+    assert_eq!(ATOMIC.fetch_max(0x10, SeqCst), 0x100);
 }
 
 fn atomic_fences() {