std: Make atomics immutable. rust-lang#11583

In Rust, the strongest guarantee that `&mut` provides is that the memory
pointed to is *not aliased*, whereas `&`'s guarantees are much weaker:
that the value can be aliased, and may be mutated under proper precautions
(interior mutability).

Our atomics though use `&mut` for mutation even while creating multiple
aliases, so this changes them to use 'interior mutability', mutating
through immutable references.

Author: brson

src/librustc/middle/typeck/check/mod.rs

@@ -3956,7 +3956,7 @@ pub fn check_intrinsic_type(ccx: @CrateCtxt, it: &ast::ForeignItem) {
 
         //We only care about the operation here
         match split[1] {
-            "cxchg" => (1, ~[ty::mk_mut_rptr(tcx,
+            "cxchg" => (1, ~[ty::mk_imm_rptr(tcx,
                                              ty::ReLateBound(it.id, ty::BrAnon(0)),
                                              param(ccx, 0)),
                         param(ccx, 0),
@@ -3970,15 +3970,15 @@ pub fn check_intrinsic_type(ccx: @CrateCtxt, it: &ast::ForeignItem) {
               param(ccx, 0)),
             "store" => (1,
                ~[
-                  ty::mk_mut_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)),
+                  ty::mk_imm_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)),
                                   param(ccx, 0)),
                   param(ccx, 0)
                ],
                ty::mk_nil()),
 
             "xchg" | "xadd" | "xsub" | "and"  | "nand" | "or" | "xor" | "max" |
             "min"  | "umax" | "umin" => {
-                (1, ~[ty::mk_mut_rptr(tcx,
+                (1, ~[ty::mk_imm_rptr(tcx,
                                       ty::ReLateBound(it.id, ty::BrAnon(0)),
                                       param(ccx, 0)), param(ccx, 0) ],
                  param(ccx, 0))

src/libstd/intrinsics.rs

@@ -164,6 +164,7 @@ pub trait TyVisitor {
     fn visit_self(&mut self) -> bool;
 }
 
+#[cfg(stage0)]
 extern "rust-intrinsic" {
     pub fn atomic_cxchg<T>(dst: &mut T, old: T, src: T) -> T;
     pub fn atomic_cxchg_acq<T>(dst: &mut T, old: T, src: T) -> T;
@@ -244,6 +245,93 @@ extern "rust-intrinsic" {
     pub fn atomic_umax_rel<T>(dst: &mut T, src: T) -> T;
     pub fn atomic_umax_acqrel<T>(dst: &mut T, src: T) -> T;
     pub fn atomic_umax_relaxed<T>(dst: &mut T, src: T) -> T;
+}
+
+#[cfg(not(stage0))]
+extern "rust-intrinsic" {
+
+    pub fn atomic_cxchg<T>(dst: &T, old: T, src: T) -> T;
+    pub fn atomic_cxchg_acq<T>(dst: &T, old: T, src: T) -> T;
+    pub fn atomic_cxchg_rel<T>(dst: &T, old: T, src: T) -> T;
+    pub fn atomic_cxchg_acqrel<T>(dst: &T, old: T, src: T) -> T;
+    pub fn atomic_cxchg_relaxed<T>(dst: &T, old: T, src: T) -> T;
+
+    pub fn atomic_load<T>(src: &T) -> T;
+    pub fn atomic_load_acq<T>(src: &T) -> T;
+    pub fn atomic_load_relaxed<T>(src: &T) -> T;
+
+    pub fn atomic_store<T>(dst: &T, val: T);
+    pub fn atomic_store_rel<T>(dst: &T, val: T);
+    pub fn atomic_store_relaxed<T>(dst: &T, val: T);
+
+    pub fn atomic_xchg<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xchg_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xchg_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xchg_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xchg_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_xadd<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xadd_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xadd_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xadd_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xadd_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_xsub<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xsub_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xsub_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xsub_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xsub_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_and<T>(dst: &T, src: T) -> T;
+    pub fn atomic_and_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_and_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_and_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_and_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_nand<T>(dst: &T, src: T) -> T;
+    pub fn atomic_nand_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_nand_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_nand_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_nand_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_or<T>(dst: &T, src: T) -> T;
+    pub fn atomic_or_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_or_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_or_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_or_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_xor<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xor_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xor_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xor_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_xor_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_max<T>(dst: &T, src: T) -> T;
+    pub fn atomic_max_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_max_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_max_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_max_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_min<T>(dst: &T, src: T) -> T;
+    pub fn atomic_min_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_min_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_min_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_min_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_umin<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umin_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umin_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umin_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umin_relaxed<T>(dst: &T, src: T) -> T;
+
+    pub fn atomic_umax<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umax_acq<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umax_rel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umax_acqrel<T>(dst: &T, src: T) -> T;
+    pub fn atomic_umax_relaxed<T>(dst: &T, src: T) -> T;
+}
+
+extern "rust-intrinsic" {
 
     pub fn atomic_fence();
     pub fn atomic_fence_acq();