add support for new RMW orders

diff --git a/src/shims/intrinsics/atomic.rs b/src/shims/intrinsics/atomic.rs
index e51fd98c5522d3275d8a1b13fcccfddd086095e6..d446eff537f31f1be283d83af6981c3f1b0e2966 100644 (file)
--- a/src/shims/intrinsics/atomic.rs
+++ b/src/shims/intrinsics/atomic.rs
@@ -49,57 +49,93 @@ fn emulate_atomic_intrinsic(
             "cxchg_seqcst_seqcst" =>
                 this.atomic_compare_exchange(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::SeqCst)?,
             #[rustfmt::skip]
-            "cxchg_acquire_acquire" =>
-                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::Acquire)?,
+            "cxchg_seqcst_acquire" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
-            "cxchg_release_relaxed" =>
-                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Release, AtomicReadOrd::Relaxed)?,
+            "cxchg_seqcst_relaxed" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Relaxed)?,
+            #[rustfmt::skip]
+            "cxchg_acqrel_seqcst" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::SeqCst)?,
             #[rustfmt::skip]
             "cxchg_acqrel_acquire" =>
                 this.atomic_compare_exchange(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
-            "cxchg_relaxed_relaxed" =>
-                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::Relaxed)?,
+            "cxchg_acqrel_relaxed" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::Relaxed)?,
+            #[rustfmt::skip]
+            "cxchg_acquire_seqcst" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::SeqCst)?,
+            #[rustfmt::skip]
+            "cxchg_acquire_acquire" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
             "cxchg_acquire_relaxed" =>
                 this.atomic_compare_exchange(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::Relaxed)?,
             #[rustfmt::skip]
-            "cxchg_acqrel_relaxed" =>
-                this.atomic_compare_exchange(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::Relaxed)?,
+            "cxchg_release_seqcst" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Release, AtomicReadOrd::SeqCst)?,
             #[rustfmt::skip]
-            "cxchg_seqcst_relaxed" =>
-                this.atomic_compare_exchange(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Relaxed)?,
+            "cxchg_release_acquire" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Release, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
-            "cxchg_seqcst_acquire" =>
-                this.atomic_compare_exchange(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Acquire)?,
+            "cxchg_release_relaxed" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Release, AtomicReadOrd::Relaxed)?,
+            #[rustfmt::skip]
+            "cxchg_relaxed_seqcst" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::SeqCst)?,
+            #[rustfmt::skip]
+            "cxchg_relaxed_acquire" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::Acquire)?,
+            #[rustfmt::skip]
+            "cxchg_relaxed_relaxed" =>
+                this.atomic_compare_exchange(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::Relaxed)?,
 
             #[rustfmt::skip]
             "cxchgweak_seqcst_seqcst" =>
                 this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::SeqCst)?,
             #[rustfmt::skip]
-            "cxchgweak_acquire_acquire" =>
-                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::Acquire)?,
+            "cxchgweak_seqcst_acquire" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
-            "cxchgweak_release_relaxed" =>
-                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Release, AtomicReadOrd::Relaxed)?,
+            "cxchgweak_seqcst_relaxed" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Relaxed)?,
+            #[rustfmt::skip]
+            "cxchgweak_acqrel_seqcst" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::SeqCst)?,
             #[rustfmt::skip]
             "cxchgweak_acqrel_acquire" =>
                 this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
-            "cxchgweak_relaxed_relaxed" =>
-                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::Relaxed)?,
+            "cxchgweak_acqrel_relaxed" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::Relaxed)?,
+            #[rustfmt::skip]
+            "cxchgweak_acquire_seqcst" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::SeqCst)?,
+            #[rustfmt::skip]
+            "cxchgweak_acquire_acquire" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
             "cxchgweak_acquire_relaxed" =>
                 this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Acquire, AtomicReadOrd::Relaxed)?,
             #[rustfmt::skip]
-            "cxchgweak_acqrel_relaxed" =>
-                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::AcqRel, AtomicReadOrd::Relaxed)?,
+            "cxchgweak_release_seqcst" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Release, AtomicReadOrd::SeqCst)?,
             #[rustfmt::skip]
-            "cxchgweak_seqcst_relaxed" =>
-                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Relaxed)?,
+            "cxchgweak_release_acquire" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Release, AtomicReadOrd::Acquire)?,
             #[rustfmt::skip]
-            "cxchgweak_seqcst_acquire" =>
-                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::SeqCst, AtomicReadOrd::Acquire)?,
+            "cxchgweak_release_relaxed" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Release, AtomicReadOrd::Relaxed)?,
+            #[rustfmt::skip]
+            "cxchgweak_relaxed_seqcst" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::SeqCst)?,
+            #[rustfmt::skip]
+            "cxchgweak_relaxed_acquire" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::Acquire)?,
+            #[rustfmt::skip]
+            "cxchgweak_relaxed_relaxed" =>
+                this.atomic_compare_exchange_weak(args, dest, AtomicRwOrd::Relaxed, AtomicReadOrd::Relaxed)?,
 
             #[rustfmt::skip]
             "or_seqcst" =>

diff --git a/tests/pass/atomic.rs b/tests/pass/atomic.rs
index 9b82e006fa162d2f0a9becc2e198b8fa61b422d5..e3d80a78916f6a22880e2c995faf9ffcb6273880 100644 (file)
--- a/tests/pass/atomic.rs
+++ b/tests/pass/atomic.rs
@@ -51,18 +51,22 @@ fn atomic_all_ops() {
     static ATOMIC: AtomicIsize = AtomicIsize::new(0);
     static ATOMIC_UNSIGNED: AtomicU64 = AtomicU64::new(0);
 
+    let load_orders = [Relaxed, Acquire, SeqCst];
+    let stored_orders = [Relaxed, Release, SeqCst];
+    let rmw_orders = [Relaxed, Release, Acquire, AcqRel, SeqCst];
+
     // loads
-    for o in [Relaxed, Acquire, SeqCst] {
+    for o in load_orders {
         ATOMIC.load(o);
     }
 
     // stores
-    for o in [Relaxed, Release, SeqCst] {
+    for o in stored_orders {
         ATOMIC.store(1, o);
     }
 
     // most RMWs
-    for o in [Relaxed, Release, Acquire, AcqRel, SeqCst] {
+    for o in rmw_orders {
         ATOMIC.swap(0, o);
         ATOMIC.fetch_or(0, o);
         ATOMIC.fetch_xor(0, o);
@@ -76,29 +80,13 @@ fn atomic_all_ops() {
         ATOMIC_UNSIGNED.fetch_max(0, o);
     }
 
-    // RMWs with deparate failure ordering
-    ATOMIC.store(0, SeqCst);
-    assert_eq!(ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed), Ok(0));
-    assert_eq!(ATOMIC.compare_exchange(0, 2, Acquire, Relaxed), Err(1));
-    assert_eq!(ATOMIC.compare_exchange(0, 1, Release, Relaxed), Err(1));
-    assert_eq!(ATOMIC.compare_exchange(1, 0, AcqRel, Relaxed), Ok(1));
-    ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
-    ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
-    ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
-    ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
-    ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
-
-    ATOMIC.store(0, SeqCst);
-    compare_exchange_weak_loop!(ATOMIC, 0, 1, Relaxed, Relaxed);
-    assert_eq!(ATOMIC.compare_exchange_weak(0, 2, Acquire, Relaxed), Err(1));
-    assert_eq!(ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed), Err(1));
-    compare_exchange_weak_loop!(ATOMIC, 1, 0, AcqRel, Relaxed);
-    assert_eq!(ATOMIC.load(Relaxed), 0);
-    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
-    ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
-    ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
-    ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
-    ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
+    // RMWs with separate failure ordering
+    for o1 in rmw_orders {
+        for o2 in load_orders {
+            let _res = ATOMIC.compare_exchange(0, 0, o1, o2);
+            let _res = ATOMIC.compare_exchange_weak(0, 0, o1, o2);
+        }
+    }
 }
 
 fn atomic_u64() {
@@ -106,7 +94,12 @@ fn atomic_u64() {
 
     ATOMIC.store(1, SeqCst);
     assert_eq!(ATOMIC.compare_exchange(0, 0x100, AcqRel, Acquire), Err(1));
+    assert_eq!(ATOMIC.compare_exchange(0, 1, Release, Relaxed), Err(1));
+    assert_eq!(ATOMIC.compare_exchange(1, 0, AcqRel, Relaxed), Ok(1));
+    assert_eq!(ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed), Ok(0));
     compare_exchange_weak_loop!(ATOMIC, 1, 0x100, AcqRel, Acquire);
+    assert_eq!(ATOMIC.compare_exchange_weak(0, 2, Acquire, Relaxed), Err(0x100));
+    assert_eq!(ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed), Err(0x100));
     assert_eq!(ATOMIC.load(Relaxed), 0x100);
 
     assert_eq!(ATOMIC.fetch_max(0x10, SeqCst), 0x100);