Add documentation for many of the atomic_* intrinsics

Part of #34338

1 files changed, 396 insertions, 0 deletions

diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index e844a158484..ea5544221c9 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -51,76 +51,472 @@ extern "rust-intrinsic" {
     // NB: These intrinsics take raw pointers because they mutate aliased
     // memory, which is not valid for either `&` or `&mut`.
 
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as both the `success` and `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as both the `success` and `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_acq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as both the `success` and `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_relaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_failacq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange).
     pub fn atomic_cxchg_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
 
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as both the `success` and `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as both the `success` and `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_acq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_rel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_acqrel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as both the `success` and `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_relaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_failacq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    /// Stores a value if the current value is the same as the `old` value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `compare_exchange_weak` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `success` and
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `failure` parameters. For example,
+    /// [`AtomicBool::compare_exchange_weak`]
+    /// (../../std/sync/atomic/struct.AtomicBool.html#method.compare_exchange_weak).
     pub fn atomic_cxchgweak_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
 
+    /// Loads the current value of the pointer.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `load` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::load`](../../std/sync/atomic/struct.AtomicBool.html#method.load).
     pub fn atomic_load<T>(src: *const T) -> T;
+    /// Loads the current value of the pointer.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `load` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::load`](../../std/sync/atomic/struct.AtomicBool.html#method.load).
     pub fn atomic_load_acq<T>(src: *const T) -> T;
+    /// Loads the current value of the pointer.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `load` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::load`](../../std/sync/atomic/struct.AtomicBool.html#method.load).
     pub fn atomic_load_relaxed<T>(src: *const T) -> T;
     pub fn atomic_load_unordered<T>(src: *const T) -> T;
 
+    /// Stores the value at the specified memory location.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `store` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::store`](../../std/sync/atomic/struct.AtomicBool.html#method.store).
     pub fn atomic_store<T>(dst: *mut T, val: T);
+    /// Stores the value at the specified memory location.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `store` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::store`](../../std/sync/atomic/struct.AtomicBool.html#method.store).
     pub fn atomic_store_rel<T>(dst: *mut T, val: T);
+    /// Stores the value at the specified memory location.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `store` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::store`](../../std/sync/atomic/struct.AtomicBool.html#method.store).
     pub fn atomic_store_relaxed<T>(dst: *mut T, val: T);
     pub fn atomic_store_unordered<T>(dst: *mut T, val: T);
 
+    /// Stores the value at the specified memory location, returning the old value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `swap` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::swap`](../../std/sync/atomic/struct.AtomicBool.html#method.swap).
     pub fn atomic_xchg<T>(dst: *mut T, src: T) -> T;
+    /// Stores the value at the specified memory location, returning the old value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `swap` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::swap`](../../std/sync/atomic/struct.AtomicBool.html#method.swap).
     pub fn atomic_xchg_acq<T>(dst: *mut T, src: T) -> T;
+    /// Stores the value at the specified memory location, returning the old value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `swap` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::swap`](../../std/sync/atomic/struct.AtomicBool.html#method.swap).
     pub fn atomic_xchg_rel<T>(dst: *mut T, src: T) -> T;
+    /// Stores the value at the specified memory location, returning the old value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `swap` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::swap`](../../std/sync/atomic/struct.AtomicBool.html#method.swap).
     pub fn atomic_xchg_acqrel<T>(dst: *mut T, src: T) -> T;
+    /// Stores the value at the specified memory location, returning the old value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `swap` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::swap`](../../std/sync/atomic/struct.AtomicBool.html#method.swap).
     pub fn atomic_xchg_relaxed<T>(dst: *mut T, src: T) -> T;
 
+    /// Add to the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_add` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
     pub fn atomic_xadd<T>(dst: *mut T, src: T) -> T;
+    /// Add to the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_add` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
     pub fn atomic_xadd_acq<T>(dst: *mut T, src: T) -> T;
+    /// Add to the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_add` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
     pub fn atomic_xadd_rel<T>(dst: *mut T, src: T) -> T;
+    /// Add to the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_add` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
     pub fn atomic_xadd_acqrel<T>(dst: *mut T, src: T) -> T;
+    /// Add to the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_add` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_add`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_add).
     pub fn atomic_xadd_relaxed<T>(dst: *mut T, src: T) -> T;
 
+    /// Subtract from the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_sub` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_sub`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_sub).
     pub fn atomic_xsub<T>(dst: *mut T, src: T) -> T;
+    /// Subtract from the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_sub` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_sub`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_sub).
     pub fn atomic_xsub_acq<T>(dst: *mut T, src: T) -> T;
+    /// Subtract from the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_sub` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_sub`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_sub).
     pub fn atomic_xsub_rel<T>(dst: *mut T, src: T) -> T;
+    /// Subtract from the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_sub` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_sub`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_sub).
     pub fn atomic_xsub_acqrel<T>(dst: *mut T, src: T) -> T;
+    /// Subtract from the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_sub` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicIsize::fetch_sub`](../../std/sync/atomic/struct.AtomicIsize.html#method.fetch_sub).
     pub fn atomic_xsub_relaxed<T>(dst: *mut T, src: T) -> T;
 
+    /// Bitwise and with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_and` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_and`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_and).
     pub fn atomic_and<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise and with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_and` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_and`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_and).
     pub fn atomic_and_acq<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise and with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_and` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_and`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_and).
     pub fn atomic_and_rel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise and with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_and` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_and`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_and).
     pub fn atomic_and_acqrel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise and with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_and` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_and`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_and).
     pub fn atomic_and_relaxed<T>(dst: *mut T, src: T) -> T;
 
+    /// Bitwise nand with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic::AtomicBool` type via the `fetch_nand` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_nand`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_nand).
     pub fn atomic_nand<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise nand with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic::AtomicBool` type via the `fetch_nand` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_nand`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_nand).
     pub fn atomic_nand_acq<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise nand with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic::AtomicBool` type via the `fetch_nand` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_nand`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_nand).
     pub fn atomic_nand_rel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise nand with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic::AtomicBool` type via the `fetch_nand` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_nand`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_nand).
     pub fn atomic_nand_acqrel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise nand with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic::AtomicBool` type via the `fetch_nand` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_nand`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_nand).
     pub fn atomic_nand_relaxed<T>(dst: *mut T, src: T) -> T;
 
+    /// Bitwise or with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_or` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_or`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_or).
     pub fn atomic_or<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise or with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_or` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_or`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_or).
     pub fn atomic_or_acq<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise or with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_or` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_or`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_or).
     pub fn atomic_or_rel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise or with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_or` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_or`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_or).
     pub fn atomic_or_acqrel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise or with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_or` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_or`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_or).
     pub fn atomic_or_relaxed<T>(dst: *mut T, src: T) -> T;
 
+    /// Bitwise xor with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_xor` method by passing
+    /// [`Ordering::SeqCst`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_xor`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_xor).
     pub fn atomic_xor<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise xor with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_xor` method by passing
+    /// [`Ordering::Acquire`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_xor`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_xor).
     pub fn atomic_xor_acq<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise xor with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_xor` method by passing
+    /// [`Ordering::Release`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_xor`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_xor).
     pub fn atomic_xor_rel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise xor with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_xor` method by passing
+    /// [`Ordering::AcqRel`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_xor`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_xor).
     pub fn atomic_xor_acqrel<T>(dst: *mut T, src: T) -> T;
+    /// Bitwise xor with the current value, returning the previous value.
+    /// The stabilized version of this intrinsic is available on the
+    /// `std::sync::atomic` types via the `fetch_xor` method by passing
+    /// [`Ordering::Relaxed`](../../std/sync/atomic/enum.Ordering.html)
+    /// as the `order`. For example,
+    /// [`AtomicBool::fetch_xor`](../../std/sync/atomic/struct.AtomicBool.html#method.fetch_xor).
     pub fn atomic_xor_relaxed<T>(dst: *mut T, src: T) -> T;
 
     pub fn atomic_max<T>(dst: *mut T, src: T) -> T;