diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 13808d6df1307..4e4fcbf392235 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -4012,7 +4012,7 @@ 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,
+            "cxchg" => (1, vec!(ty::mk_imm_rptr(tcx,
                                              ty::ReLateBound(it.id, ty::BrAnon(0)),
                                              param(ccx, 0)),
                         param(ccx, 0),
@@ -4025,7 +4025,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
               param(ccx, 0)),
             "store" => (1,
                vec!(
-                  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)
                ),
@@ -4033,7 +4033,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
 
             "xchg" | "xadd" | "xsub" | "and"  | "nand" | "or" | "xor" | "max" |
             "min"  | "umax" | "umin" => {
-                (1, vec!(ty::mk_mut_rptr(tcx,
+                (1, vec!(ty::mk_imm_rptr(tcx,
                                       ty::ReLateBound(it.id, ty::BrAnon(0)),
                                       param(ccx, 0)), param(ccx, 0) ),
                  param(ccx, 0))
diff --git a/src/libstd/intrinsics.rs b/src/libstd/intrinsics.rs
index f0ea36c251ede..8125d2fc8b86c 100644
--- a/src/libstd/intrinsics.rs
+++ b/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();
diff --git a/src/libstd/sync/atomics.rs b/src/libstd/sync/atomics.rs
index cbdb38c1c58b6..2e57b6022c661 100644
--- a/src/libstd/sync/atomics.rs
+++ b/src/libstd/sync/atomics.rs
@@ -222,7 +222,7 @@ impl AtomicBool {
 
     /// Store the value
     #[inline]
-    pub fn store(&mut self, val: bool, order: Ordering) {
+    pub fn store(&self, val: bool, order: Ordering) {
         let val = if val { UINT_TRUE } else { 0 };
 
         unsafe { atomic_store(&mut *self.v.get(), val, order); }
@@ -230,7 +230,7 @@ impl AtomicBool {
 
     /// Store a value, returning the old value
     #[inline]
-    pub fn swap(&mut self, val: bool, order: Ordering) -> bool {
+    pub fn swap(&self, val: bool, order: Ordering) -> bool {
         let val = if val { UINT_TRUE } else { 0 };
 
         unsafe { atomic_swap(&mut *self.v.get(), val, order) > 0 }
@@ -282,7 +282,7 @@ impl AtomicBool {
     /// }
     /// ```
     #[inline]
-    pub fn compare_and_swap(&mut self, old: bool, new: bool, order: Ordering) -> bool {
+    pub fn compare_and_swap(&self, old: bool, new: bool, order: Ordering) -> bool {
         let old = if old { UINT_TRUE } else { 0 };
         let new = if new { UINT_TRUE } else { 0 };
 
@@ -313,7 +313,7 @@ impl AtomicBool {
     /// assert_eq!(false, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_and(&mut self, val: bool, order: Ordering) -> bool {
+    pub fn fetch_and(&self, val: bool, order: Ordering) -> bool {
         let val = if val { UINT_TRUE } else { 0 };
 
         unsafe { atomic_and(&mut *self.v.get(), val, order) > 0 }
@@ -344,7 +344,7 @@ impl AtomicBool {
     /// assert_eq!(true, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_nand(&mut self, val: bool, order: Ordering) -> bool {
+    pub fn fetch_nand(&self, val: bool, order: Ordering) -> bool {
         let val = if val { UINT_TRUE } else { 0 };
 
         unsafe { atomic_nand(&mut *self.v.get(), val, order) > 0 }
@@ -374,7 +374,7 @@ impl AtomicBool {
     /// assert_eq!(false, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_or(&mut self, val: bool, order: Ordering) -> bool {
+    pub fn fetch_or(&self, val: bool, order: Ordering) -> bool {
         let val = if val { UINT_TRUE } else { 0 };
 
         unsafe { atomic_or(&mut *self.v.get(), val, order) > 0 }
@@ -404,7 +404,7 @@ impl AtomicBool {
     /// assert_eq!(false, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_xor(&mut self, val: bool, order: Ordering) -> bool {
+    pub fn fetch_xor(&self, val: bool, order: Ordering) -> bool {
         let val = if val { UINT_TRUE } else { 0 };
 
         unsafe { atomic_xor(&mut *self.v.get(), val, order) > 0 }
@@ -425,13 +425,13 @@ impl AtomicInt {
 
     /// Store the value
     #[inline]
-    pub fn store(&mut self, val: int, order: Ordering) {
+    pub fn store(&self, val: int, order: Ordering) {
         unsafe { atomic_store(&mut *self.v.get(), val, order); }
     }
 
     /// Store a value, returning the old value
     #[inline]
-    pub fn swap(&mut self, val: int, order: Ordering) -> int {
+    pub fn swap(&self, val: int, order: Ordering) -> int {
         unsafe { atomic_swap(&mut *self.v.get(), val, order) }
     }
 
@@ -441,7 +441,7 @@ impl AtomicInt {
     /// replace the current value with `new`. Return the previous value.
     /// If the return value is equal to `old` then the value was updated.
     #[inline]
-    pub fn compare_and_swap(&mut self, old: int, new: int, order: Ordering) -> int {
+    pub fn compare_and_swap(&self, old: int, new: int, order: Ordering) -> int {
         unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
     }
 
@@ -457,7 +457,7 @@ impl AtomicInt {
     /// assert_eq!(10, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_add(&mut self, val: int, order: Ordering) -> int {
+    pub fn fetch_add(&self, val: int, order: Ordering) -> int {
         unsafe { atomic_add(&mut *self.v.get(), val, order) }
     }
 
@@ -473,7 +473,7 @@ impl AtomicInt {
     /// assert_eq!(-10, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_sub(&mut self, val: int, order: Ordering) -> int {
+    pub fn fetch_sub(&self, val: int, order: Ordering) -> int {
         unsafe { atomic_sub(&mut *self.v.get(), val, order) }
     }
 }
@@ -493,27 +493,27 @@ impl AtomicU64 {
     }
 
     #[inline]
-    pub fn store(&mut self, val: u64, order: Ordering) {
+    pub fn store(&self, val: u64, order: Ordering) {
         unsafe { atomic_store(&mut *self.v.get(), val, order); }
     }
 
     #[inline]
-    pub fn swap(&mut self, val: u64, order: Ordering) -> u64 {
+    pub fn swap(&self, val: u64, order: Ordering) -> u64 {
         unsafe { atomic_swap(&mut *self.v.get(), val, order) }
     }
 
     #[inline]
-    pub fn compare_and_swap(&mut self, old: u64, new: u64, order: Ordering) -> u64 {
+    pub fn compare_and_swap(&self, old: u64, new: u64, order: Ordering) -> u64 {
         unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
     }
 
     #[inline]
-    pub fn fetch_add(&mut self, val: u64, order: Ordering) -> u64 {
+    pub fn fetch_add(&self, val: u64, order: Ordering) -> u64 {
         unsafe { atomic_add(&mut *self.v.get(), val, order) }
     }
 
     #[inline]
-    pub fn fetch_sub(&mut self, val: u64, order: Ordering) -> u64 {
+    pub fn fetch_sub(&self, val: u64, order: Ordering) -> u64 {
         unsafe { atomic_sub(&mut *self.v.get(), val, order) }
     }
 }
@@ -532,13 +532,13 @@ impl AtomicUint {
 
     /// Store the value
     #[inline]
-    pub fn store(&mut self, val: uint, order: Ordering) {
+    pub fn store(&self, val: uint, order: Ordering) {
         unsafe { atomic_store(&mut *self.v.get(), val, order); }
     }
 
     /// Store a value, returning the old value
     #[inline]
-    pub fn swap(&mut self, val: uint, order: Ordering) -> uint {
+    pub fn swap(&self, val: uint, order: Ordering) -> uint {
         unsafe { atomic_swap(&mut *self.v.get(), val, order) }
     }
 
@@ -548,7 +548,7 @@ impl AtomicUint {
     /// replace the current value with `new`. Return the previous value.
     /// If the return value is equal to `old` then the value was updated.
     #[inline]
-    pub fn compare_and_swap(&mut self, old: uint, new: uint, order: Ordering) -> uint {
+    pub fn compare_and_swap(&self, old: uint, new: uint, order: Ordering) -> uint {
         unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
     }
 
@@ -564,7 +564,7 @@ impl AtomicUint {
     /// assert_eq!(10, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_add(&mut self, val: uint, order: Ordering) -> uint {
+    pub fn fetch_add(&self, val: uint, order: Ordering) -> uint {
         unsafe { atomic_add(&mut *self.v.get(), val, order) }
     }
 
@@ -580,7 +580,7 @@ impl AtomicUint {
     /// assert_eq!(0, foo.load(SeqCst));
     /// ```
     #[inline]
-    pub fn fetch_sub(&mut self, val: uint, order: Ordering) -> uint {
+    pub fn fetch_sub(&self, val: uint, order: Ordering) -> uint {
         unsafe { atomic_sub(&mut *self.v.get(), val, order) }
     }
 }
@@ -601,13 +601,13 @@ impl<T> AtomicPtr<T> {
 
     /// Store the value
     #[inline]
-    pub fn store(&mut self, ptr: *mut T, order: Ordering) {
+    pub fn store(&self, ptr: *mut T, order: Ordering) {
         unsafe { atomic_store(&mut *self.p.get(), ptr as uint, order); }
     }
 
     /// Store a value, returning the old value
     #[inline]
-    pub fn swap(&mut self, ptr: *mut T, order: Ordering) -> *mut T {
+    pub fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T {
         unsafe { atomic_swap(&mut *self.p.get(), ptr as uint, order) as *mut T }
     }
 
@@ -617,7 +617,7 @@ impl<T> AtomicPtr<T> {
     /// replace the current value with `new`. Return the previous value.
     /// If the return value is equal to `old` then the value was updated.
     #[inline]
-    pub fn compare_and_swap(&mut self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
+    pub fn compare_and_swap(&self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
         unsafe {
             atomic_compare_and_swap(&mut *self.p.get(), old as uint,
                                     new as uint, order) as *mut T
@@ -636,7 +636,7 @@ impl<T> AtomicOption<T> {
 
     /// Store a value, returning the old value
     #[inline]
-    pub fn swap(&mut self, val: ~T, order: Ordering) -> Option<~T> {
+    pub fn swap(&self, val: ~T, order: Ordering) -> Option<~T> {
         unsafe {
             let val = cast::transmute(val);
 
@@ -651,7 +651,7 @@ impl<T> AtomicOption<T> {
 
     /// Remove the value, leaving the `AtomicOption` empty.
     #[inline]
-    pub fn take(&mut self, order: Ordering) -> Option<~T> {
+    pub fn take(&self, order: Ordering) -> Option<~T> {
         unsafe { self.swap(cast::transmute(0), order) }
     }
 
@@ -661,7 +661,7 @@ impl<T> AtomicOption<T> {
     /// the option was already `Some`, returns `Some` of the rejected
     /// value.
     #[inline]
-    pub fn fill(&mut self, val: ~T, order: Ordering) -> Option<~T> {
+    pub fn fill(&self, val: ~T, order: Ordering) -> Option<~T> {
         unsafe {
             let val = cast::transmute(val);
             let expected = cast::transmute(0);
@@ -679,7 +679,7 @@ impl<T> AtomicOption<T> {
     /// Be careful: The caller must have some external method of ensuring the
     /// result does not get invalidated by another task after this returns.
     #[inline]
-    pub fn is_empty(&mut self, order: Ordering) -> bool {
+    pub fn is_empty(&self, order: Ordering) -> bool {
         unsafe { atomic_load(&*self.p.get(), order) as uint == 0 }
     }
 }
@@ -692,7 +692,7 @@ impl<T> Drop for AtomicOption<T> {
 }
 
 #[inline]
-pub unsafe fn atomic_store<T>(dst: &mut T, val: T, order:Ordering) {
+pub unsafe fn atomic_store<T>(dst: &T, val: T, order:Ordering) {
     match order {
         Release => intrinsics::atomic_store_rel(dst, val),
         Relaxed => intrinsics::atomic_store_relaxed(dst, val),
@@ -710,7 +710,7 @@ pub unsafe fn atomic_load<T>(dst: &T, order:Ordering) -> T {
 }
 
 #[inline]
-pub unsafe fn atomic_swap<T>(dst: &mut T, val: T, order: Ordering) -> T {
+pub unsafe fn atomic_swap<T>(dst: &T, val: T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_xchg_acq(dst, val),
         Release => intrinsics::atomic_xchg_rel(dst, val),
@@ -722,7 +722,7 @@ pub unsafe fn atomic_swap<T>(dst: &mut T, val: T, order: Ordering) -> T {
 
 /// Returns the old value (like __sync_fetch_and_add).
 #[inline]
-pub unsafe fn atomic_add<T>(dst: &mut T, val: T, order: Ordering) -> T {
+pub unsafe fn atomic_add<T>(dst: &T, val: T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_xadd_acq(dst, val),
         Release => intrinsics::atomic_xadd_rel(dst, val),
@@ -734,7 +734,7 @@ pub unsafe fn atomic_add<T>(dst: &mut T, val: T, order: Ordering) -> T {
 
 /// Returns the old value (like __sync_fetch_and_sub).
 #[inline]
-pub unsafe fn atomic_sub<T>(dst: &mut T, val: T, order: Ordering) -> T {
+pub unsafe fn atomic_sub<T>(dst: &T, val: T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_xsub_acq(dst, val),
         Release => intrinsics::atomic_xsub_rel(dst, val),
@@ -745,7 +745,7 @@ pub unsafe fn atomic_sub<T>(dst: &mut T, val: T, order: Ordering) -> T {
 }
 
 #[inline]
-pub unsafe fn atomic_compare_and_swap<T>(dst:&mut T, old:T, new:T, order: Ordering) -> T {
+pub unsafe fn atomic_compare_and_swap<T>(dst:&T, old:T, new:T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_cxchg_acq(dst, old, new),
         Release => intrinsics::atomic_cxchg_rel(dst, old, new),
@@ -756,7 +756,7 @@ pub unsafe fn atomic_compare_and_swap<T>(dst:&mut T, old:T, new:T, order: Orderi
 }
 
 #[inline]
-pub unsafe fn atomic_and<T>(dst: &mut T, val: T, order: Ordering) -> T {
+pub unsafe fn atomic_and<T>(dst: &T, val: T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_and_acq(dst, val),
         Release => intrinsics::atomic_and_rel(dst, val),
@@ -767,7 +767,7 @@ pub unsafe fn atomic_and<T>(dst: &mut T, val: T, order: Ordering) -> T {
 }
 
 #[inline]
-pub unsafe fn atomic_nand<T>(dst: &mut T, val: T, order: Ordering) -> T {
+pub unsafe fn atomic_nand<T>(dst: &T, val: T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_nand_acq(dst, val),
         Release => intrinsics::atomic_nand_rel(dst, val),
@@ -779,7 +779,7 @@ pub unsafe fn atomic_nand<T>(dst: &mut T, val: T, order: Ordering) -> T {
 
 
 #[inline]
-pub unsafe fn atomic_or<T>(dst: &mut T, val: T, order: Ordering) -> T {
+pub unsafe fn atomic_or<T>(dst: &T, val: T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_or_acq(dst, val),
         Release => intrinsics::atomic_or_rel(dst, val),
@@ -791,7 +791,7 @@ pub unsafe fn atomic_or<T>(dst: &mut T, val: T, order: Ordering) -> T {
 
 
 #[inline]
-pub unsafe fn atomic_xor<T>(dst: &mut T, val: T, order: Ordering) -> T {
+pub unsafe fn atomic_xor<T>(dst: &T, val: T, order: Ordering) -> T {
     match order {
         Acquire => intrinsics::atomic_xor_acq(dst, val),
         Release => intrinsics::atomic_xor_rel(dst, val),
@@ -914,16 +914,16 @@ mod test {
     fn different_sizes() {
         unsafe {
             let mut slot = 0u16;
-            assert_eq!(super::atomic_swap(&mut slot, 1, SeqCst), 0);
+            assert_eq!(super::atomic_swap(&slot, 1, SeqCst), 0);
 
             let mut slot = 0u8;
-            assert_eq!(super::atomic_compare_and_swap(&mut slot, 1, 2, SeqCst), 0);
+            assert_eq!(super::atomic_compare_and_swap(&slot, 1, 2, SeqCst), 0);
 
             let mut slot = 0u32;
-            assert_eq!(super::atomic_load(&mut slot, SeqCst), 0);
+            assert_eq!(super::atomic_load(&slot, SeqCst), 0);
 
             let mut slot = 0u64;
-            super::atomic_store(&mut slot, 2, SeqCst);
+            super::atomic_store(&slot, 2, SeqCst);
         }
     }
 }
diff --git a/src/libstd/sync/atomics_stage0.rs b/src/libstd/sync/atomics_stage0.rs
new file mode 100644
index 0000000000000..b501972532d62
--- /dev/null
+++ b/src/libstd/sync/atomics_stage0.rs
@@ -0,0 +1,930 @@
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Atomic types
+//!
+//! Atomic types provide primitive shared-memory communication between
+//! threads, and are the building blocks of other concurrent
+//! types.
+//!
+//! This module defines atomic versions of a select number of primitive
+//! types, including `AtomicBool`, `AtomicInt`, `AtomicUint`, and `AtomicOption`.
+//! Atomic types present operations that, when used correctly, synchronize
+//! updates between threads.
+//!
+//! Each method takes an `Ordering` which represents the strength of
+//! the memory barrier for that operation. These orderings are the
+//! same as [C++11 atomic orderings][1].
+//!
+//! [1]: http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync
+//!
+//! Atomic variables are safe to share between threads (they implement `Share`)
+//! but they do not themselves provide the mechanism for sharing. The most
+//! common way to share an atomic variable is to put it into an `Arc` (an
+//! atomically-reference-counted shared pointer).
+//!
+//! Most atomic types may be stored in static variables, initialized using
+//! the provided static initializers like `INIT_ATOMIC_BOOL`. Atomic statics
+//! are often used for lazy global initialization.
+//!
+//!
+//! # Examples
+//!
+//! A simple spinlock:
+//!
+//! ```ignore
+//! # // FIXME: Needs PR #12430
+//! extern crate sync;
+//!
+//! use sync::Arc;
+//! use std::sync::atomics::{AtomicUint, SeqCst};
+//! use std::task::deschedule;
+//!
+//! fn main() {
+//!     let spinlock = Arc::new(AtomicUint::new(1));
+//!
+//!     let spinlock_clone = spinlock.clone();
+//!     spawn(proc() {
+//!         spinlock_clone.store(0, SeqCst);
+//!     });
+//!
+//!     // Wait for the other task to release the lock
+//!     while spinlock.load(SeqCst) != 0 {
+//!         // Since tasks may not be preemptive (if they are green threads)
+//!         // yield to the scheduler to let the other task run. Low level
+//!         // concurrent code needs to take into account Rust's two threading
+//!         // models.
+//!         deschedule();
+//!     }
+//! }
+//! ```
+//!
+//! Transferring a heap object with `AtomicOption`:
+//!
+//! ```ignore
+//! # // FIXME: Needs PR #12430
+//! extern crate sync;
+//!
+//! use sync::Arc;
+//! use std::sync::atomics::{AtomicOption, SeqCst};
+//!
+//! fn main() {
+//!     struct BigObject;
+//!
+//!     let shared_big_object = Arc::new(AtomicOption::empty());
+//!
+//!     let shared_big_object_clone = shared_big_object.clone();
+//!     spawn(proc() {
+//!         let unwrapped_big_object = shared_big_object_clone.take(SeqCst);
+//!         if unwrapped_big_object.is_some() {
+//!             println!("got a big object from another task");
+//!         } else {
+//!             println!("other task hasn't sent big object yet");
+//!         }
+//!     });
+//!
+//!     shared_big_object.swap(~BigObject, SeqCst);
+//! }
+//! ```
+//!
+//! Keep a global count of live tasks:
+//!
+//! ```
+//! use std::sync::atomics::{AtomicUint, SeqCst, INIT_ATOMIC_UINT};
+//!
+//! static mut GLOBAL_TASK_COUNT: AtomicUint = INIT_ATOMIC_UINT;
+//!
+//! unsafe {
+//!     let old_task_count = GLOBAL_TASK_COUNT.fetch_add(1, SeqCst);
+//!     println!("live tasks: {}", old_task_count + 1);
+//! }
+//! ```
+
+#[allow(missing_doc)];
+
+use intrinsics;
+use cast;
+use std::kinds::marker;
+use option::{Option,Some,None};
+use ops::Drop;
+use ty::Unsafe;
+
+/// An atomic boolean type.
+pub struct AtomicBool {
+    priv v: Unsafe<uint>,
+    priv nopod: marker::NoPod
+}
+
+/// A signed atomic integer type, supporting basic atomic arithmetic operations
+pub struct AtomicInt {
+    priv v: Unsafe<int>,
+    priv nopod: marker::NoPod
+}
+
+/// An unsigned atomic integer type, supporting basic atomic arithmetic operations
+pub struct AtomicUint {
+    priv v: Unsafe<uint>,
+    priv nopod: marker::NoPod
+}
+
+/// An unsigned atomic integer type that is forced to be 64-bits. This does not
+/// support all operations.
+pub struct AtomicU64 {
+    priv v: Unsafe<u64>,
+    priv nopod: marker::NoPod
+}
+
+/// An unsafe atomic pointer. Only supports basic atomic operations
+pub struct AtomicPtr<T> {
+    priv p: Unsafe<uint>,
+    priv nopod: marker::NoPod
+}
+
+/// An atomic, nullable unique pointer
+///
+/// This can be used as the concurrency primitive for operations that transfer
+/// owned heap objects across tasks.
+#[unsafe_no_drop_flag]
+pub struct AtomicOption<T> {
+    priv p: Unsafe<uint>,
+}
+
+/// Atomic memory orderings
+///
+/// Memory orderings limit the ways that both the compiler and CPU may reorder
+/// instructions around atomic operations. At its most restrictive,
+/// "sequentially consistent" atomics allow neither reads nor writes
+/// to be moved either before or after the atomic operation; on the other end
+/// "relaxed" atomics allow all reorderings.
+///
+/// Rust's memory orderings are the same as in C++[1].
+///
+/// [1]: http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync
+pub enum Ordering {
+    /// No ordering constraints, only atomic operations
+    Relaxed,
+    /// When coupled with a store, all previous writes become visible
+    /// to another thread that performs a load with `Acquire` ordering
+    /// on the same value
+    Release,
+    /// When coupled with a load, all subsequent loads will see data
+    /// written before a store with `Release` ordering on the same value
+    /// in another thread
+    Acquire,
+    /// When coupled with a load, uses `Acquire` ordering, and with a store
+    /// `Release` ordering
+    AcqRel,
+    /// Like `AcqRel` with the additional guarantee that all threads see all
+    /// sequentially consistent operations in the same order.
+    SeqCst
+}
+
+/// An `AtomicBool` initialized to `false`
+pub static INIT_ATOMIC_BOOL : AtomicBool = AtomicBool { v: Unsafe{value: 0,
+                                                                  marker1: marker::InvariantType},
+                                                        nopod: marker::NoPod };
+/// An `AtomicInt` initialized to `0`
+pub static INIT_ATOMIC_INT  : AtomicInt  = AtomicInt  { v: Unsafe{value: 0,
+                                                                  marker1: marker::InvariantType},
+                                                        nopod: marker::NoPod };
+/// An `AtomicUint` initialized to `0`
+pub static INIT_ATOMIC_UINT : AtomicUint = AtomicUint { v: Unsafe{value: 0,
+                                                                  marker1: marker::InvariantType},
+                                                        nopod: marker::NoPod };
+/// An `AtomicU64` initialized to `0`
+pub static INIT_ATOMIC_U64 : AtomicU64 = AtomicU64 { v: Unsafe{value: 0,
+                                                               marker1: marker::InvariantType},
+                                                     nopod: marker::NoPod };
+
+
+// NB: Needs to be -1 (0b11111111...) to make fetch_nand work correctly
+static UINT_TRUE: uint = -1;
+
+impl AtomicBool {
+    /// Create a new `AtomicBool`
+    pub fn new(v: bool) -> AtomicBool {
+        let val = if v { UINT_TRUE } else { 0 };
+        AtomicBool { v: Unsafe::new(val), nopod: marker::NoPod }
+    }
+
+    /// Load the value
+    #[inline]
+    pub fn load(&self, order: Ordering) -> bool {
+        unsafe { atomic_load(&*self.v.get(), order) > 0 }
+    }
+
+    /// Store the value
+    #[inline]
+    pub fn store(&mut self, val: bool, order: Ordering) {
+        let val = if val { UINT_TRUE } else { 0 };
+
+        unsafe { atomic_store(&mut *self.v.get(), val, order); }
+    }
+
+    /// Store a value, returning the old value
+    #[inline]
+    pub fn swap(&mut self, val: bool, order: Ordering) -> bool {
+        let val = if val { UINT_TRUE } else { 0 };
+
+        unsafe { atomic_swap(&mut *self.v.get(), val, order) > 0 }
+    }
+
+    /// If the current value is the same as expected, store a new value
+    ///
+    /// Compare the current value with `old`; if they are the same then
+    /// replace the current value with `new`. Return the previous value.
+    /// If the return value is equal to `old` then the value was updated.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// # // FIXME: Needs PR #12430
+    /// extern crate sync;
+    ///
+    /// use sync::Arc;
+    /// use std::sync::atomics::{AtomicBool, SeqCst};
+    ///
+    /// fn main() {
+    ///     let spinlock = Arc::new(AtomicBool::new(false));
+    ///     let spinlock_clone = spin_lock.clone();
+    ///
+    ///     spawn(proc() {
+    ///         with_lock(&spinlock, || println!("task 1 in lock"));
+    ///     });
+    ///
+    ///     spawn(proc() {
+    ///         with_lock(&spinlock_clone, || println!("task 2 in lock"));
+    ///     });
+    /// }
+    ///
+    /// fn with_lock(spinlock: &Arc<AtomicBool>, f: || -> ()) {
+    ///     // CAS loop until we are able to replace `false` with `true`
+    ///     while spinlock.compare_and_swap(false, true, SeqCst) == false {
+    ///         // Since tasks may not be preemptive (if they are green threads)
+    ///         // yield to the scheduler to let the other task run. Low level
+    ///         // concurrent code needs to take into account Rust's two threading
+    ///         // models.
+    ///         deschedule();
+    ///     }
+    ///
+    ///     // Now we have the spinlock
+    ///     f();
+    ///
+    ///     // Release the lock
+    ///     spinlock.store(false);
+    /// }
+    /// ```
+    #[inline]
+    pub fn compare_and_swap(&mut self, old: bool, new: bool, order: Ordering) -> bool {
+        let old = if old { UINT_TRUE } else { 0 };
+        let new = if new { UINT_TRUE } else { 0 };
+
+        unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) > 0 }
+    }
+
+    /// A logical "and" operation
+    ///
+    /// Performs a logical "and" operation on the current value and the
+    /// argument `val`, and sets the new value to the result.
+    /// Returns the previous value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicBool, SeqCst};
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_and(false, SeqCst));
+    /// assert_eq!(false, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_and(true, SeqCst));
+    /// assert_eq!(true, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(false);
+    /// assert_eq!(false, foo.fetch_and(false, SeqCst));
+    /// assert_eq!(false, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_and(&mut self, val: bool, order: Ordering) -> bool {
+        let val = if val { UINT_TRUE } else { 0 };
+
+        unsafe { atomic_and(&mut *self.v.get(), val, order) > 0 }
+    }
+
+    /// A logical "nand" operation
+    ///
+    /// Performs a logical "nand" operation on the current value and the
+    /// argument `val`, and sets the new value to the result.
+    /// Returns the previous value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicBool, SeqCst};
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_nand(false, SeqCst));
+    /// assert_eq!(true, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_nand(true, SeqCst));
+    /// assert_eq!(0, foo.load(SeqCst) as int);
+    /// assert_eq!(false, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(false);
+    /// assert_eq!(false, foo.fetch_nand(false, SeqCst));
+    /// assert_eq!(true, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_nand(&mut self, val: bool, order: Ordering) -> bool {
+        let val = if val { UINT_TRUE } else { 0 };
+
+        unsafe { atomic_nand(&mut *self.v.get(), val, order) > 0 }
+    }
+
+    /// A logical "or" operation
+    ///
+    /// Performs a logical "or" operation on the current value and the
+    /// argument `val`, and sets the new value to the result.
+    /// Returns the previous value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicBool, SeqCst};
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_or(false, SeqCst));
+    /// assert_eq!(true, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_or(true, SeqCst));
+    /// assert_eq!(true, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(false);
+    /// assert_eq!(false, foo.fetch_or(false, SeqCst));
+    /// assert_eq!(false, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_or(&mut self, val: bool, order: Ordering) -> bool {
+        let val = if val { UINT_TRUE } else { 0 };
+
+        unsafe { atomic_or(&mut *self.v.get(), val, order) > 0 }
+    }
+
+    /// A logical "xor" operation
+    ///
+    /// Performs a logical "xor" operation on the current value and the
+    /// argument `val`, and sets the new value to the result.
+    /// Returns the previous value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicBool, SeqCst};
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_xor(false, SeqCst));
+    /// assert_eq!(true, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(true);
+    /// assert_eq!(true, foo.fetch_xor(true, SeqCst));
+    /// assert_eq!(false, foo.load(SeqCst));
+    ///
+    /// let mut foo = AtomicBool::new(false);
+    /// assert_eq!(false, foo.fetch_xor(false, SeqCst));
+    /// assert_eq!(false, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_xor(&mut self, val: bool, order: Ordering) -> bool {
+        let val = if val { UINT_TRUE } else { 0 };
+
+        unsafe { atomic_xor(&mut *self.v.get(), val, order) > 0 }
+    }
+}
+
+impl AtomicInt {
+    /// Create a new `AtomicInt`
+    pub fn new(v: int) -> AtomicInt {
+        AtomicInt {v: Unsafe::new(v), nopod: marker::NoPod}
+    }
+
+    /// Load the value
+    #[inline]
+    pub fn load(&self, order: Ordering) -> int {
+        unsafe { atomic_load(&*self.v.get(), order) }
+    }
+
+    /// Store the value
+    #[inline]
+    pub fn store(&mut self, val: int, order: Ordering) {
+        unsafe { atomic_store(&mut *self.v.get(), val, order); }
+    }
+
+    /// Store a value, returning the old value
+    #[inline]
+    pub fn swap(&mut self, val: int, order: Ordering) -> int {
+        unsafe { atomic_swap(&mut *self.v.get(), val, order) }
+    }
+
+    /// If the current value is the same as expected, store a new value
+    ///
+    /// Compare the current value with `old`; if they are the same then
+    /// replace the current value with `new`. Return the previous value.
+    /// If the return value is equal to `old` then the value was updated.
+    #[inline]
+    pub fn compare_and_swap(&mut self, old: int, new: int, order: Ordering) -> int {
+        unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
+    }
+
+    /// Add to the current value, returning the previous
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicInt, SeqCst};
+    ///
+    /// let mut foo = AtomicInt::new(0);
+    /// assert_eq!(0, foo.fetch_add(10, SeqCst));
+    /// assert_eq!(10, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_add(&mut self, val: int, order: Ordering) -> int {
+        unsafe { atomic_add(&mut *self.v.get(), val, order) }
+    }
+
+    /// Subtract from the current value, returning the previous
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicInt, SeqCst};
+    ///
+    /// let mut foo = AtomicInt::new(0);
+    /// assert_eq!(0, foo.fetch_sub(10, SeqCst));
+    /// assert_eq!(-10, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_sub(&mut self, val: int, order: Ordering) -> int {
+        unsafe { atomic_sub(&mut *self.v.get(), val, order) }
+    }
+}
+
+// temporary workaround
+// it causes link failure on MIPS target
+// libgcc doesn't implement 64-bit atomic operations for MIPS32
+#[cfg(not(target_arch = "mips"))]
+impl AtomicU64 {
+    pub fn new(v: u64) -> AtomicU64 {
+        AtomicU64 { v: Unsafe::new(v), nopod: marker::NoPod }
+    }
+
+    #[inline]
+    pub fn load(&self, order: Ordering) -> u64 {
+        unsafe { atomic_load(&*self.v.get(), order) }
+    }
+
+    #[inline]
+    pub fn store(&mut self, val: u64, order: Ordering) {
+        unsafe { atomic_store(&mut *self.v.get(), val, order); }
+    }
+
+    #[inline]
+    pub fn swap(&mut self, val: u64, order: Ordering) -> u64 {
+        unsafe { atomic_swap(&mut *self.v.get(), val, order) }
+    }
+
+    #[inline]
+    pub fn compare_and_swap(&mut self, old: u64, new: u64, order: Ordering) -> u64 {
+        unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
+    }
+
+    #[inline]
+    pub fn fetch_add(&mut self, val: u64, order: Ordering) -> u64 {
+        unsafe { atomic_add(&mut *self.v.get(), val, order) }
+    }
+
+    #[inline]
+    pub fn fetch_sub(&mut self, val: u64, order: Ordering) -> u64 {
+        unsafe { atomic_sub(&mut *self.v.get(), val, order) }
+    }
+}
+
+impl AtomicUint {
+    /// Create a new `AtomicUint`
+    pub fn new(v: uint) -> AtomicUint {
+        AtomicUint { v: Unsafe::new(v), nopod: marker::NoPod }
+    }
+
+    /// Load the value
+    #[inline]
+    pub fn load(&self, order: Ordering) -> uint {
+        unsafe { atomic_load(&*self.v.get(), order) }
+    }
+
+    /// Store the value
+    #[inline]
+    pub fn store(&mut self, val: uint, order: Ordering) {
+        unsafe { atomic_store(&mut *self.v.get(), val, order); }
+    }
+
+    /// Store a value, returning the old value
+    #[inline]
+    pub fn swap(&mut self, val: uint, order: Ordering) -> uint {
+        unsafe { atomic_swap(&mut *self.v.get(), val, order) }
+    }
+
+    /// If the current value is the same as expected, store a new value
+    ///
+    /// Compare the current value with `old`; if they are the same then
+    /// replace the current value with `new`. Return the previous value.
+    /// If the return value is equal to `old` then the value was updated.
+    #[inline]
+    pub fn compare_and_swap(&mut self, old: uint, new: uint, order: Ordering) -> uint {
+        unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
+    }
+
+    /// Add to the current value, returning the previous
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicUint, SeqCst};
+    ///
+    /// let mut foo = AtomicUint::new(0);
+    /// assert_eq!(0, foo.fetch_add(10, SeqCst));
+    /// assert_eq!(10, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_add(&mut self, val: uint, order: Ordering) -> uint {
+        unsafe { atomic_add(&mut *self.v.get(), val, order) }
+    }
+
+    /// Subtract from the current value, returning the previous
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::sync::atomics::{AtomicUint, SeqCst};
+    ///
+    /// let mut foo = AtomicUint::new(10);
+    /// assert_eq!(10, foo.fetch_sub(10, SeqCst));
+    /// assert_eq!(0, foo.load(SeqCst));
+    /// ```
+    #[inline]
+    pub fn fetch_sub(&mut self, val: uint, order: Ordering) -> uint {
+        unsafe { atomic_sub(&mut *self.v.get(), val, order) }
+    }
+}
+
+impl<T> AtomicPtr<T> {
+    /// Create a new `AtomicPtr`
+    pub fn new(p: *mut T) -> AtomicPtr<T> {
+        AtomicPtr { p: Unsafe::new(p as uint), nopod: marker::NoPod }
+    }
+
+    /// Load the value
+    #[inline]
+    pub fn load(&self, order: Ordering) -> *mut T {
+        unsafe {
+            atomic_load(&*self.p.get(), order) as *mut T
+        }
+    }
+
+    /// Store the value
+    #[inline]
+    pub fn store(&mut self, ptr: *mut T, order: Ordering) {
+        unsafe { atomic_store(&mut *self.p.get(), ptr as uint, order); }
+    }
+
+    /// Store a value, returning the old value
+    #[inline]
+    pub fn swap(&mut self, ptr: *mut T, order: Ordering) -> *mut T {
+        unsafe { atomic_swap(&mut *self.p.get(), ptr as uint, order) as *mut T }
+    }
+
+    /// If the current value is the same as expected, store a new value
+    ///
+    /// Compare the current value with `old`; if they are the same then
+    /// replace the current value with `new`. Return the previous value.
+    /// If the return value is equal to `old` then the value was updated.
+    #[inline]
+    pub fn compare_and_swap(&mut self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
+        unsafe {
+            atomic_compare_and_swap(&mut *self.p.get(), old as uint,
+                                    new as uint, order) as *mut T
+        }
+    }
+}
+
+impl<T> AtomicOption<T> {
+    /// Create a new `AtomicOption`
+    pub fn new(p: ~T) -> AtomicOption<T> {
+        unsafe { AtomicOption { p: Unsafe::new(cast::transmute(p)) } }
+    }
+
+    /// Create a new `AtomicOption` that doesn't contain a value
+    pub fn empty() -> AtomicOption<T> { AtomicOption { p: Unsafe::new(0) } }
+
+    /// Store a value, returning the old value
+    #[inline]
+    pub fn swap(&mut self, val: ~T, order: Ordering) -> Option<~T> {
+        unsafe {
+            let val = cast::transmute(val);
+
+            let p = atomic_swap(&mut *self.p.get(), val, order);
+            if p as uint == 0 {
+                None
+            } else {
+                Some(cast::transmute(p))
+            }
+        }
+    }
+
+    /// Remove the value, leaving the `AtomicOption` empty.
+    #[inline]
+    pub fn take(&mut self, order: Ordering) -> Option<~T> {
+        unsafe { self.swap(cast::transmute(0), order) }
+    }
+
+    /// Replace an empty value with a non-empty value.
+    ///
+    /// Succeeds if the option is `None` and returns `None` if so. If
+    /// the option was already `Some`, returns `Some` of the rejected
+    /// value.
+    #[inline]
+    pub fn fill(&mut self, val: ~T, order: Ordering) -> Option<~T> {
+        unsafe {
+            let val = cast::transmute(val);
+            let expected = cast::transmute(0);
+            let oldval = atomic_compare_and_swap(&mut *self.p.get(), expected, val, order);
+            if oldval == expected {
+                None
+            } else {
+                Some(cast::transmute(val))
+            }
+        }
+    }
+
+    /// Returns `true` if the `AtomicOption` is empty.
+    ///
+    /// Be careful: The caller must have some external method of ensuring the
+    /// result does not get invalidated by another task after this returns.
+    #[inline]
+    pub fn is_empty(&mut self, order: Ordering) -> bool {
+        unsafe { atomic_load(&*self.p.get(), order) as uint == 0 }
+    }
+}
+
+#[unsafe_destructor]
+impl<T> Drop for AtomicOption<T> {
+    fn drop(&mut self) {
+        let _ = self.take(SeqCst);
+    }
+}
+
+#[inline]
+pub unsafe fn atomic_store<T>(dst: &mut T, val: T, order:Ordering) {
+    match order {
+        Release => intrinsics::atomic_store_rel(dst, val),
+        Relaxed => intrinsics::atomic_store_relaxed(dst, val),
+        _       => intrinsics::atomic_store(dst, val)
+    }
+}
+
+#[inline]
+pub unsafe fn atomic_load<T>(dst: &T, order:Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_load_acq(dst),
+        Relaxed => intrinsics::atomic_load_relaxed(dst),
+        _       => intrinsics::atomic_load(dst)
+    }
+}
+
+#[inline]
+pub unsafe fn atomic_swap<T>(dst: &mut T, val: T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_xchg_acq(dst, val),
+        Release => intrinsics::atomic_xchg_rel(dst, val),
+        AcqRel  => intrinsics::atomic_xchg_acqrel(dst, val),
+        Relaxed => intrinsics::atomic_xchg_relaxed(dst, val),
+        _       => intrinsics::atomic_xchg(dst, val)
+    }
+}
+
+/// Returns the old value (like __sync_fetch_and_add).
+#[inline]
+pub unsafe fn atomic_add<T>(dst: &mut T, val: T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_xadd_acq(dst, val),
+        Release => intrinsics::atomic_xadd_rel(dst, val),
+        AcqRel  => intrinsics::atomic_xadd_acqrel(dst, val),
+        Relaxed => intrinsics::atomic_xadd_relaxed(dst, val),
+        _       => intrinsics::atomic_xadd(dst, val)
+    }
+}
+
+/// Returns the old value (like __sync_fetch_and_sub).
+#[inline]
+pub unsafe fn atomic_sub<T>(dst: &mut T, val: T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_xsub_acq(dst, val),
+        Release => intrinsics::atomic_xsub_rel(dst, val),
+        AcqRel  => intrinsics::atomic_xsub_acqrel(dst, val),
+        Relaxed => intrinsics::atomic_xsub_relaxed(dst, val),
+        _       => intrinsics::atomic_xsub(dst, val)
+    }
+}
+
+#[inline]
+pub unsafe fn atomic_compare_and_swap<T>(dst:&mut T, old:T, new:T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_cxchg_acq(dst, old, new),
+        Release => intrinsics::atomic_cxchg_rel(dst, old, new),
+        AcqRel  => intrinsics::atomic_cxchg_acqrel(dst, old, new),
+        Relaxed => intrinsics::atomic_cxchg_relaxed(dst, old, new),
+        _       => intrinsics::atomic_cxchg(dst, old, new),
+    }
+}
+
+#[inline]
+pub unsafe fn atomic_and<T>(dst: &mut T, val: T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_and_acq(dst, val),
+        Release => intrinsics::atomic_and_rel(dst, val),
+        AcqRel  => intrinsics::atomic_and_acqrel(dst, val),
+        Relaxed => intrinsics::atomic_and_relaxed(dst, val),
+        _       => intrinsics::atomic_and(dst, val)
+    }
+}
+
+#[inline]
+pub unsafe fn atomic_nand<T>(dst: &mut T, val: T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_nand_acq(dst, val),
+        Release => intrinsics::atomic_nand_rel(dst, val),
+        AcqRel  => intrinsics::atomic_nand_acqrel(dst, val),
+        Relaxed => intrinsics::atomic_nand_relaxed(dst, val),
+        _       => intrinsics::atomic_nand(dst, val)
+    }
+}
+
+
+#[inline]
+pub unsafe fn atomic_or<T>(dst: &mut T, val: T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_or_acq(dst, val),
+        Release => intrinsics::atomic_or_rel(dst, val),
+        AcqRel  => intrinsics::atomic_or_acqrel(dst, val),
+        Relaxed => intrinsics::atomic_or_relaxed(dst, val),
+        _       => intrinsics::atomic_or(dst, val)
+    }
+}
+
+
+#[inline]
+pub unsafe fn atomic_xor<T>(dst: &mut T, val: T, order: Ordering) -> T {
+    match order {
+        Acquire => intrinsics::atomic_xor_acq(dst, val),
+        Release => intrinsics::atomic_xor_rel(dst, val),
+        AcqRel  => intrinsics::atomic_xor_acqrel(dst, val),
+        Relaxed => intrinsics::atomic_xor_relaxed(dst, val),
+        _       => intrinsics::atomic_xor(dst, val)
+    }
+}
+
+
+/// An atomic fence.
+///
+/// A fence 'A' which has `Release` ordering semantics, synchronizes with a
+/// fence 'B' with (at least) `Acquire` semantics, if and only if there exists
+/// atomic operations X and Y, both operating on some atomic object 'M' such
+/// that A is sequenced before X, Y is synchronized before B and Y observers
+/// the change to M. This provides a happens-before dependence between A and B.
+///
+/// Atomic operations with `Release` or `Acquire` semantics can also synchronize
+/// with a fence.
+///
+/// A fence with has `SeqCst` ordering, in addition to having both `Acquire` and
+/// `Release` semantics, participates in the global program order of the other
+/// `SeqCst` operations and/or fences.
+///
+/// Accepts `Acquire`, `Release`, `AcqRel` and `SeqCst` orderings.
+///
+/// # Failure
+///
+/// Fails if `order` is `Relaxed`
+#[inline]
+pub fn fence(order: Ordering) {
+    unsafe {
+        match order {
+            Acquire => intrinsics::atomic_fence_acq(),
+            Release => intrinsics::atomic_fence_rel(),
+            AcqRel  => intrinsics::atomic_fence_acqrel(),
+            SeqCst  => intrinsics::atomic_fence(),
+            Relaxed => fail!("there is no such thing as a relaxed fence")
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use option::*;
+    use super::*;
+
+    #[test]
+    fn bool_() {
+        let mut a = AtomicBool::new(false);
+        assert_eq!(a.compare_and_swap(false, true, SeqCst), false);
+        assert_eq!(a.compare_and_swap(false, true, SeqCst), true);
+
+        a.store(false, SeqCst);
+        assert_eq!(a.compare_and_swap(false, true, SeqCst), false);
+    }
+
+    #[test]
+    fn option_empty() {
+        let mut option: AtomicOption<()> = AtomicOption::empty();
+        assert!(option.is_empty(SeqCst));
+    }
+
+    #[test]
+    fn option_swap() {
+        let mut p = AtomicOption::new(~1);
+        let a = ~2;
+
+        let b = p.swap(a, SeqCst);
+
+        assert_eq!(b, Some(~1));
+        assert_eq!(p.take(SeqCst), Some(~2));
+    }
+
+    #[test]
+    fn option_take() {
+        let mut p = AtomicOption::new(~1);
+
+        assert_eq!(p.take(SeqCst), Some(~1));
+        assert_eq!(p.take(SeqCst), None);
+
+        let p2 = ~2;
+        p.swap(p2, SeqCst);
+
+        assert_eq!(p.take(SeqCst), Some(~2));
+    }
+
+    #[test]
+    fn option_fill() {
+        let mut p = AtomicOption::new(~1);
+        assert!(p.fill(~2, SeqCst).is_some()); // should fail; shouldn't leak!
+        assert_eq!(p.take(SeqCst), Some(~1));
+
+        assert!(p.fill(~2, SeqCst).is_none()); // shouldn't fail
+        assert_eq!(p.take(SeqCst), Some(~2));
+    }
+
+    #[test]
+    fn bool_and() {
+        let mut a = AtomicBool::new(true);
+        assert_eq!(a.fetch_and(false, SeqCst),true);
+        assert_eq!(a.load(SeqCst),false);
+    }
+
+    static mut S_BOOL : AtomicBool = INIT_ATOMIC_BOOL;
+    static mut S_INT  : AtomicInt  = INIT_ATOMIC_INT;
+    static mut S_UINT : AtomicUint = INIT_ATOMIC_UINT;
+
+    #[test]
+    fn static_init() {
+        unsafe {
+            assert!(!S_BOOL.load(SeqCst));
+            assert!(S_INT.load(SeqCst) == 0);
+            assert!(S_UINT.load(SeqCst) == 0);
+        }
+    }
+
+    #[test]
+    fn different_sizes() {
+        unsafe {
+            let mut slot = 0u16;
+            assert_eq!(super::atomic_swap(&mut slot, 1, SeqCst), 0);
+
+            let mut slot = 0u8;
+            assert_eq!(super::atomic_compare_and_swap(&mut slot, 1, 2, SeqCst), 0);
+
+            let mut slot = 0u32;
+            assert_eq!(super::atomic_load(&mut slot, SeqCst), 0);
+
+            let mut slot = 0u64;
+            super::atomic_store(&mut slot, 2, SeqCst);
+        }
+    }
+}
+
diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs
index 3213c538152c6..994d12b34e5aa 100644
--- a/src/libstd/sync/mod.rs
+++ b/src/libstd/sync/mod.rs
@@ -16,6 +16,10 @@
 //! other types of concurrent primitives.
 
 pub mod arc;
+#[cfg(stage0)]
+#[path = "atomics_stage0.rs"]
+pub mod atomics;
+#[cfg(not(stage0))]
 pub mod atomics;
 pub mod deque;
 pub mod mpmc_bounded_queue;
diff --git a/src/test/auxiliary/cci_intrinsic.rs b/src/test/auxiliary/cci_intrinsic.rs
index 07d6df89d220c..b7278f64289e0 100644
--- a/src/test/auxiliary/cci_intrinsic.rs
+++ b/src/test/auxiliary/cci_intrinsic.rs
@@ -10,21 +10,21 @@
 
 pub mod rusti {
     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;
-        pub fn atomic_cxchg_rel<T>(dst: &mut T, old: T, src: T) -> T;
+        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_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<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_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<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_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<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;
     }
 }
 
diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs
index d6e394a345e22..cb1f8ed60187f 100644
--- a/src/test/run-pass/intrinsic-atomics.rs
+++ b/src/test/run-pass/intrinsic-atomics.rs
@@ -10,27 +10,27 @@
 
 mod rusti {
     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;
-        pub fn atomic_cxchg_rel<T>(dst: &mut T, old: T, src: T) -> T;
+        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_load<T>(src: &T) -> T;
         pub fn atomic_load_acq<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<T>(dst: &T, val: T);
+        pub fn atomic_store_rel<T>(dst: &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<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_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<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_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<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;
     }
 }