Change:
Today if one navigates to the docs to, for example, () you see this warning: But not all intrinsics have stabilized interfaces, and even when they exist this message is not helpful in determining exactly what those interfaces are. In the specific example of , this should mention that its stabilized interface is (). Intrinsics that do not have such stabilized interfaces should have instead reference issues in the Rust bug tracker that involve creating stabilized interfaces, or alternately a metabug that covers all unstable intrinsics that do not have stable interfaces. If it has been decided that a given intrinsic will never have a stabilized interface for whatever reason, then the unstable documentation attribute should contain the reason why, and/or a link to the discussion where such a decision was arrived upon.
Revisiting this, today the intrinsics docs warning message no longer says anything about "instead they should be used through stabilized interfaces in the rest of the standard library", which obviates half of this bug by no longer causing doc readers to wonder at what the stable replacement might be. It also seems that some of the intrinsics have had this issue addressed (e.g. my original example of volatile_store). While it would still be valuable to be sure that any intrinsic with a stable counterpart has that counterpart mentioned in its docs, I'd say that this bug could be closed at the blessing of the docs team.
Triage: Punting this to docs team; the unstable attribute doesn't carry any additional information for intrinsics, so any link back to one's stable interface would have to go into the hand-written portion of their docs. That means that this is effectively a checklist issue, if anyone is interested in taking this up... :eyes:
I just saw that if you click the "This is a nightly-only experimental API."-part in  it still expands and shows the message: "intrinsics are unlikely to ever be stabilized, instead they should be used through stabilized interfaces in the rest of the standard library". I don't mind picking up this issue! I just have three questions: Should the expanded intrinsics message be removed (about them unlikely to be ever stabilized)? Would you like me to create a checklist? (Create a new issue for this, or somehow copy this in the original message again for easy discoverability when reading this issue?) Where could I find the stable interfaces associated with each intrinsic?
Could you maybe still respond to my previous message? Then hopefully I can take this up soon!
Hello! For definitive answers to those questions I would direct you to ask the docs team, but I can hazard guesses: 's desirable that intrinsics mention that they aren't candidates for stabilization, so that people are absolutely clear about the stability/portability guarantees of the API. checklist would be great, yes! If you manage to come up with a simple list of intrinsics that need documenting I can edit it into the original issue body. the stabilized versions of each intrinsic is probably a matter of asking around; at least as of when this issue was filed part of the problem was that there wasn't such a document available. :P
I’ve started working on this, I will probably open a PR pretty soon For the moment, I have documented the / operations, the and functions, and some memory-related functions
Great to hear that!
Thank you both for your hard work! I think implements this issue and we can probably close this now I guess? Or am I missing something? I have been off for a a few months (more then I would have hoped for...) but I am finally back to do some work again :)
Closing this as it is fixed.

Discussion:
// NB: These intrinsics take raw pointers because they mutate aliased // memory, which is not valid for either `&` or `&mut`. <ins> /// 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). </ins> pub fn atomic_cxchg<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_acq<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_relaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_failacq<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchg_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_acq<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_rel<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_acqrel<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_relaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_failacq<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_cxchgweak_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool); <ins> /// 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). </ins> pub fn atomic_load<T>(src: *const T) -> T; <ins> /// 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). </ins> pub fn atomic_load_acq<T>(src: *const T) -> T; <ins> /// 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). </ins> pub fn atomic_load_relaxed<T>(src: *const T) -> T; pub fn atomic_load_unordered<T>(src: *const T) -> T; <ins> /// 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). </ins> pub fn atomic_store<T>(dst: *mut T, val: T); <ins> /// 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). </ins> pub fn atomic_store_rel<T>(dst: *mut T, val: T); <ins> /// 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). </ins> pub fn atomic_store_relaxed<T>(dst: *mut T, val: T); pub fn atomic_store_unordered<T>(dst: *mut T, val: T); <ins> /// 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). </ins> pub fn atomic_xchg<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xchg_acq<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xchg_rel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xchg_acqrel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xchg_relaxed<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xadd<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xadd_acq<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xadd_rel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xadd_acqrel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xadd_relaxed<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xsub<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xsub_acq<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xsub_rel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xsub_acqrel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xsub_relaxed<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_and<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_and_acq<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_and_rel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_and_acqrel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_and_relaxed<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_nand<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_nand_acq<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_nand_rel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_nand_acqrel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_nand_relaxed<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_or<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_or_acq<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_or_rel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_or_acqrel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_or_relaxed<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xor<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xor_acq<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xor_rel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> pub fn atomic_xor_acqrel<T>(dst: *mut T, src: T) -> T; <ins> /// 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). </ins> 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 volatile_set_memory<T>(dst: *mut T, val: u8, count: usize); /// Perform a volatile load from the `src` pointer. <ins> /// The stabilized version of this intrinsic is /// [`std::ptr::read_volatile`](../../std/ptr/fn.read_volatile.html). </ins> pub fn volatile_load<T>(src: *const T) -> T; /// Perform a volatile store to the `dst` pointer. <ins> /// The stabilized version of this intrinsic is /// [`std::ptr::write_volatile`](../../std/ptr/fn.write_volatile.html). </ins> pub fn volatile_store<T>(dst: *mut T, val: T); /// Returns the square root of an `f32`

pub fn bswap<T>(x: T) -> T; /// Performs checked integer addition. <ins> /// The stabilized versions of this intrinsic are available on the integer /// primitives via the `overflowing_add` method. For example, /// [`std::u32::overflowing_add`](../../std/primitive.u32.html#method.overflowing_add) </ins> pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool); /// Performs checked integer subtraction <ins> /// The stabilized versions of this intrinsic are available on the integer /// primitives via the `overflowing_sub` method. For example, /// [`std::u32::overflowing_sub`](../../std/primitive.u32.html#method.overflowing_sub) </ins> pub fn sub_with_overflow<T>(x: T, y: T) -> (T, bool); /// Performs checked integer multiplication <ins> /// The stabilized versions of this intrinsic are available on the integer /// primitives via the `overflowing_mul` method. For example, /// [`std::u32::overflowing_mul`](../../std/primitive.u32.html#method.overflowing_mul) </ins> pub fn mul_with_overflow<T>(x: T, y: T) -> (T, bool); /// Performs an unchecked division, resulting in undefined behavior

pub fn unchecked_rem<T>(x: T, y: T) -> T; /// Returns (a + b) mod 2^N, where N is the width of T in bits. <ins> /// The stabilized versions of this intrinsic are available on the integer /// primitives via the `wrapping_add` method. For example, /// [`std::u32::wrapping_add`](../../std/primitive.u32.html#method.wrapping_add) </ins> pub fn overflowing_add<T>(a: T, b: T) -> T; /// Returns (a - b) mod 2^N, where N is the width of T in bits. <ins> /// The stabilized versions of this intrinsic are available on the integer /// primitives via the `wrapping_sub` method. For example, /// [`std::u32::wrapping_sub`](../../std/primitive.u32.html#method.wrapping_sub) </ins> pub fn overflowing_sub<T>(a: T, b: T) -> T; /// Returns (a * b) mod 2^N, where N is the width of T in bits. <ins> /// The stabilized versions of this intrinsic are available on the integer /// primitives via the `wrapping_mul` method. For example, /// [`std::u32::wrapping_mul`](../../std/primitive.u32.html#method.wrapping_mul) </ins> pub fn overflowing_mul<T>(a: T, b: T) -> T; /// Returns the value of the discriminant for the variant in 'v',