auto merge of #13036 : alexcrichton/rust/atomics, r=alexcrichton

Closes #11583, rebasing of #12430 now that we've got `Share` and better analysis with statics.

Author: bors

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

@@ -4011,30 +4011,18 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
 
         //We only care about the operation here
         match *split.get(1) {
-            "cxchg" => (1, vec!(ty::mk_mut_rptr(tcx,
-                                             ty::ReLateBound(it.id, ty::BrAnon(0)),
-                                             param(ccx, 0)),
-                        param(ccx, 0),
-                        param(ccx, 0)), param(ccx, 0)),
-            "load" => (1,
-               vec!(
-                  ty::mk_imm_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)),
-                                  param(ccx, 0))
-               ),
-              param(ccx, 0)),
-            "store" => (1,
-               vec!(
-                  ty::mk_mut_rptr(tcx, ty::ReLateBound(it.id, ty::BrAnon(0)),
-                                  param(ccx, 0)),
-                  param(ccx, 0)
-               ),
-               ty::mk_nil()),
+            "cxchg" => (1, vec!(ty::mk_mut_ptr(tcx, param(ccx, 0)),
+                                param(ccx, 0),
+                                param(ccx, 0)),
+                        param(ccx, 0)),
+            "load" => (1, vec!(ty::mk_imm_ptr(tcx, param(ccx, 0))),
+                       param(ccx, 0)),
+            "store" => (1, vec!(ty::mk_mut_ptr(tcx, param(ccx, 0)), param(ccx, 0)),
+                        ty::mk_nil()),
 
             "xchg" | "xadd" | "xsub" | "and"  | "nand" | "or" | "xor" | "max" |
             "min"  | "umax" | "umin" => {
-                (1, vec!(ty::mk_mut_rptr(tcx,
-                                      ty::ReLateBound(it.id, ty::BrAnon(0)),
-                                      param(ccx, 0)), param(ccx, 0) ),
+                (1, vec!(ty::mk_mut_ptr(tcx, param(ccx, 0)), param(ccx, 0)),
                  param(ccx, 0))
             }
             "fence" => {

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,96 @@ 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" {
+
+    // NB: These intrinsics take unsafe pointers because they mutate aliased
+    // memory, which is not valid for either `&` or `&mut`.
+
+    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;
+    pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> T;
+    pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> T;
+    pub fn atomic_cxchg_relaxed<T>(dst: *mut 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: *mut T, val: T);
+    pub fn atomic_store_rel<T>(dst: *mut T, val: T);
+    pub fn atomic_store_relaxed<T>(dst: *mut T, val: T);
+
+    pub fn atomic_xchg<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xchg_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xchg_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xchg_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xchg_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_xadd<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xadd_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xadd_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xadd_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xadd_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_xsub<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xsub_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xsub_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xsub_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xsub_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_and<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_and_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_and_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_and_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_and_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_nand<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_nand_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_nand_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_nand_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_nand_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_or<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_or_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_or_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_or_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_or_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_xor<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xor_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xor_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xor_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_xor_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_max<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_max_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_max_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_max_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_max_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_min<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_min_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_min_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_min_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_min_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_umin<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_umin_acq<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_umin_rel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_umin_acqrel<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_umin_relaxed<T>(dst: *mut T, src: T) -> T;
+
+    pub fn atomic_umax<T>(dst: *mut T, src: T) -> T;
+    pub fn atomic_umax_acq<T>(dst: *mut T, src: T) -> T;
+    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;
+}
+
+extern "rust-intrinsic" {
 
     pub fn atomic_fence();
     pub fn atomic_fence_acq();