core::intrinsics - Rust
Description: API documentation for the Rust `intrinsics` mod in crate `core`.
Keywords: rust, rustlang, rust-lang, intrinsics

# [−][src]Module core::intrinsics

🔬 This is a nightly-only experimental API. (`core_intrinsics` #0)

intrinsics are unlikely to ever be stabilized, instead they should be used through stabilized interfaces in the rest of the standard library

Compiler intrinsics.

The corresponding definitions are in `librustc_codegen_llvm/intrinsic.rs`.

# Volatiles

The volatile intrinsics provide operations intended to act on I/O memory, which are guaranteed to not be reordered by the compiler across other volatile intrinsics. See the LLVM documentation on [volatile].

# Atomics

The atomic intrinsics provide common atomic operations on machine words, with multiple possible memory orderings. They obey the same semantics as C++11. See the LLVM documentation on [atomics].

A quick refresher on memory ordering:

- Acquire - a barrier for acquiring a lock. Subsequent reads and writes take place after the barrier.
- Release - a barrier for releasing a lock. Preceding reads and writes take place before the barrier.
- Sequentially consistent - sequentially consistent operations are guaranteed to happen in order. This is the standard mode for working with atomic types and is equivalent to Java's `volatile`.

## Re-exports

`pub use crate::ptr::drop_in_place;`

## Functions

copy⚠ | Copies `count * size_of::<T>()` bytes from `src` to `dst`. The source and destination may overlap.
copy_nonoverlapping⚠ | Copies `count * size_of::<T>()` bytes from `src` to `dst`. The source and destination must not overlap.
transmute⚠ | Reinterprets the bits of a value of one type as another type.
write_bytes⚠ | Sets `count * size_of::<T>()` bytes of memory starting at `dst` to `val`.
abort⚠ | Experimental Aborts the execution of the process.
add_with_overflow⚠ | Experimental Performs checked integer addition. The stabilized versions of this intrinsic are available on the integer primitives via the `overflowing_add` method. For example, `std::u32::overflowing_add`
arith_offset⚠ | Experimental Calculates the offset from a pointer, potentially wrapping.
assume⚠ | Experimental Informs the optimizer that a condition is always true. If the condition is false, the behavior is undefined.
atomic_and⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_and`.
atomic_and_acq⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_and`.
atomic_and_acqrel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_and`.
atomic_and_rel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_and`.
atomic_and_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_and`.
atomic_cxchg⚠ | Experimental 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` as both the `success` and `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_acq⚠ | Experimental 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` as both the `success` and `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_acq_failrelaxed⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_acqrel⚠ | Experimental 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` as the `success` and `Ordering::Acquire` as the `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_acqrel_failrelaxed⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_failacq⚠ | Experimental 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` as the `success` and `Ordering::Acquire` as the `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_failrelaxed⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_rel⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchg_relaxed⚠ | Experimental 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` as both the `success` and `failure` parameters. For example, `AtomicBool::compare_exchange`.
atomic_cxchgweak⚠ | Experimental 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` as both the `success` and `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_acq⚠ | Experimental 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` as both the `success` and `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_acq_failrelaxed⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_acqrel⚠ | Experimental 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` as the `success` and `Ordering::Acquire` as the `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_acqrel_failrelaxed⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_failacq⚠ | Experimental 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` as the `success` and `Ordering::Acquire` as the `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_failrelaxed⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_rel⚠ | Experimental 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` as the `success` and `Ordering::Relaxed` as the `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_cxchgweak_relaxed⚠ | Experimental 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` as both the `success` and `failure` parameters. For example, `AtomicBool::compare_exchange_weak`.
atomic_fence⚠ | Experimental
atomic_fence_acq⚠ | Experimental
atomic_fence_acqrel⚠ | Experimental
atomic_fence_rel⚠ | Experimental
atomic_load⚠ | Experimental 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` as the `order`. For example, `AtomicBool::load`.
atomic_load_acq⚠ | Experimental 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` as the `order`. For example, `AtomicBool::load`.
atomic_load_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicBool::load`.
atomic_load_unordered⚠ | Experimental
atomic_max⚠ | Experimental
atomic_max_acq⚠ | Experimental
atomic_max_acqrel⚠ | Experimental
atomic_max_rel⚠ | Experimental
atomic_max_relaxed⚠ | Experimental
atomic_min⚠ | Experimental
atomic_min_acq⚠ | Experimental
atomic_min_acqrel⚠ | Experimental
atomic_min_rel⚠ | Experimental
atomic_min_relaxed⚠ | Experimental
atomic_nand⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_nand`.
atomic_nand_acq⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_nand`.
atomic_nand_acqrel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_nand`.
atomic_nand_rel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_nand`.
atomic_nand_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_nand`.
atomic_or⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_or`.
atomic_or_acq⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_or`.
atomic_or_acqrel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_or`.
atomic_or_rel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_or`.
atomic_or_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_or`.
atomic_singlethreadfence⚠ | Experimental A compiler-only memory barrier.
atomic_singlethreadfence_acq⚠ | Experimental
atomic_singlethreadfence_acqrel⚠ | Experimental
atomic_singlethreadfence_rel⚠ | Experimental
atomic_store⚠ | Experimental 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` as the `order`. For example, `AtomicBool::store`.
atomic_store_rel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::store`.
atomic_store_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicBool::store`.
atomic_store_unordered⚠ | Experimental
atomic_umax⚠ | Experimental
atomic_umax_acq⚠ | Experimental
atomic_umax_acqrel⚠ | Experimental
atomic_umax_rel⚠ | Experimental
atomic_umax_relaxed⚠ | Experimental
atomic_umin⚠ | Experimental
atomic_umin_acq⚠ | Experimental
atomic_umin_acqrel⚠ | Experimental
atomic_umin_rel⚠ | Experimental
atomic_umin_relaxed⚠ | Experimental
atomic_xadd⚠ | Experimental Adds 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_acq⚠ | Experimental Adds 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_acqrel⚠ | Experimental Adds 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_rel⚠ | Experimental Adds 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_relaxed⚠ | Experimental Adds 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xchg⚠ | Experimental 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` as the `order`. For example, `AtomicBool::swap`.
atomic_xchg_acq⚠ | Experimental 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` as the `order`. For example, `AtomicBool::swap`.
atomic_xchg_acqrel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::swap`.
atomic_xchg_rel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::swap`.
atomic_xchg_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicBool::swap`.
atomic_xor⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_xor`.
atomic_xor_acq⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_xor`.
atomic_xor_acqrel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_xor`.
atomic_xor_rel⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_xor`.
atomic_xor_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicBool::fetch_xor`.
atomic_xsub⚠ | Experimental 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` as the `order`. For example, `AtomicIsize::fetch_sub`.
atomic_xsub_acq⚠ | Experimental 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` as the `order`. For example, `AtomicIsize::fetch_sub`.
atomic_xsub_acqrel⚠ | Experimental 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` as the `order`. For example, `AtomicIsize::fetch_sub`.
atomic_xsub_rel⚠ | Experimental 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` as the `order`. For example, `AtomicIsize::fetch_sub`.
atomic_xsub_relaxed⚠ | Experimental 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` as the `order`. For example, `AtomicIsize::fetch_sub`.
bitreverse⚠ | Experimental Reverses the bits in an integer type `T`.
breakpoint⚠ | Experimental Executes a breakpoint trap, for inspection by a debugger.
bswap⚠ | Experimental Reverses the bytes in an integer type `T`.
ceilf32⚠ | Experimental Returns the smallest integer greater than or equal to an `f32`.
ceilf64⚠ | Experimental Returns the smallest integer greater than or equal to an `f64`.
copysignf32⚠ | Experimental Copies the sign from `y` to `x` for `f32` values.
copysignf64⚠ | Experimental Copies the sign from `y` to `x` for `f64` values.
cosf32⚠ | Experimental Returns the cosine of an `f32`.
cosf64⚠ | Experimental Returns the cosine of an `f64`.
ctlz⚠ | Experimental Returns the number of leading unset bits (zeroes) in an integer type `T`.
ctlz_nonzero⚠ | Experimental Like `ctlz`, but extra-unsafe as it returns `undef` when given an `x` with value `0`.
ctpop⚠ | Experimental Returns the number of bits set in an integer type `T`
cttz⚠ | Experimental Returns the number of trailing unset bits (zeroes) in an integer type `T`.
cttz_nonzero⚠ | Experimental Like `cttz`, but extra-unsafe as it returns `undef` when given an `x` with value `0`.
discriminant_value⚠ | Experimental Returns the value of the discriminant for the variant in 'v', cast to a `u64`; if `T` has no discriminant, returns 0.
exact_div⚠ | Experimental Performs an exact division, resulting in undefined behavior where `x % y != 0` or `y == 0` or `x == T::min_value() && y == -1`
exp2f32⚠ | Experimental Returns 2 raised to the power of an `f32`.
exp2f64⚠ | Experimental Returns 2 raised to the power of an `f64`.
expf32⚠ | Experimental Returns the exponential of an `f32`.
expf64⚠ | Experimental Returns the exponential of an `f64`.
fabsf32⚠ | Experimental Returns the absolute value of an `f32`.
fabsf64⚠ | Experimental Returns the absolute value of an `f64`.
fadd_fast⚠ | Experimental Float addition that allows optimizations based on algebraic rules. May assume inputs are finite.
fdiv_fast⚠ | Experimental Float division that allows optimizations based on algebraic rules. May assume inputs are finite.
floorf32⚠ | Experimental Returns the largest integer less than or equal to an `f32`.
floorf64⚠ | Experimental Returns the largest integer less than or equal to an `f64`.
fmaf32⚠ | Experimental Returns `a * b + c` for `f32` values.
fmaf64⚠ | Experimental Returns `a * b + c` for `f64` values.
fmul_fast⚠ | Experimental Float multiplication that allows optimizations based on algebraic rules. May assume inputs are finite.
forget⚠ | Experimental Moves a value out of scope without running drop glue.
frem_fast⚠ | Experimental Float remainder that allows optimizations based on algebraic rules. May assume inputs are finite.
fsub_fast⚠ | Experimental Float subtraction that allows optimizations based on algebraic rules. May assume inputs are finite.
init⚠ | DeprecatedExperimental Creates a value initialized to zero.
likely⚠ | Experimental Hints to the compiler that branch condition is likely to be true. Returns the value passed to it.
log10f32⚠ | Experimental Returns the base 10 logarithm of an `f32`.
log10f64⚠ | Experimental Returns the base 10 logarithm of an `f64`.
log2f32⚠ | Experimental Returns the base 2 logarithm of an `f32`.
log2f64⚠ | Experimental Returns the base 2 logarithm of an `f64`.
logf32⚠ | Experimental Returns the natural logarithm of an `f32`.
logf64⚠ | Experimental Returns the natural logarithm of an `f64`.
maxnumf32⚠ | Experimental Returns the maximum of two `f32` values.
maxnumf64⚠ | Experimental Returns the maximum of two `f64` values.
min_align_of⚠ | Experimental
min_align_of_val⚠ | Experimental
minnumf32⚠ | Experimental Returns the minimum of two `f32` values.
minnumf64⚠ | Experimental Returns the minimum of two `f64` values.
move_val_init⚠ | Experimental Moves a value to an uninitialized memory location.
mul_with_overflow⚠ | Experimental Performs checked integer multiplication The stabilized versions of this intrinsic are available on the integer primitives via the `overflowing_mul` method. For example, `std::u32::overflowing_mul`
nearbyintf32⚠ | Experimental Returns the nearest integer to an `f32`.
nearbyintf64⚠ | Experimental Returns the nearest integer to an `f64`.
needs_drop⚠ | Experimental Returns `true` if the actual type given as `T` requires drop glue; returns `false` if the actual type provided for `T` implements `Copy`.
nontemporal_store⚠ | Experimental Emits a `!nontemporal` store according to LLVM (see their docs). Probably will never become stable.
offset⚠ | Experimental Calculates the offset from a pointer.
overflowing_add⚠ | Experimental Returns (a + b) mod 2N, where N is the width of T in bits. The stabilized versions of this intrinsic are available on the integer primitives via the `wrapping_add` method. For example, `std::u32::wrapping_add`
overflowing_mul⚠ | Experimental Returns (a * b) mod 2N, where N is the width of T in bits. The stabilized versions of this intrinsic are available on the integer primitives via the `wrapping_mul` method. For example, `std::u32::wrapping_mul`
overflowing_sub⚠ | Experimental Returns (a - b) mod 2N, where N is the width of T in bits. The stabilized versions of this intrinsic are available on the integer primitives via the `wrapping_sub` method. For example, `std::u32::wrapping_sub`
panic_if_uninhabited⚠ | Experimental A guard for unsafe functions that cannot ever be executed if `T` is uninhabited: This will statically either panic, or do nothing.
powf32⚠ | Experimental Raises an `f32` to an `f32` power.
powf64⚠ | Experimental Raises an `f64` to an `f64` power.
powif32⚠ | Experimental Raises an `f32` to an integer power.
powif64⚠ | Experimental Raises an `f64` to an integer power.
pref_align_of⚠ | Experimental
prefetch_read_data⚠ | Experimental The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction if supported; otherwise, it is a no-op. Prefetches have no effect on the behavior of the program but can change its performance characteristics.
prefetch_read_instruction⚠ | Experimental The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction if supported; otherwise, it is a no-op. Prefetches have no effect on the behavior of the program but can change its performance characteristics.
prefetch_write_data⚠ | Experimental The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction if supported; otherwise, it is a no-op. Prefetches have no effect on the behavior of the program but can change its performance characteristics.
prefetch_write_instruction⚠ | Experimental The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction if supported; otherwise, it is a no-op. Prefetches have no effect on the behavior of the program but can change its performance characteristics.
rintf32⚠ | Experimental Returns the nearest integer to an `f32`. May raise an inexact floating-point exception if the argument is not an integer.
rintf64⚠ | Experimental Returns the nearest integer to an `f64`. May raise an inexact floating-point exception if the argument is not an integer.
rotate_left⚠ | Experimental Performs rotate left. The stabilized versions of this intrinsic are available on the integer primitives via the `rotate_left` method. For example, `std::u32::rotate_left`
rotate_right⚠ | Experimental Performs rotate right. The stabilized versions of this intrinsic are available on the integer primitives via the `rotate_right` method. For example, `std::u32::rotate_right`
roundf32⚠ | Experimental Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
roundf64⚠ | Experimental Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
rustc_peek⚠ | Experimental Magic intrinsic that derives its meaning from attributes attached to the function.
saturating_add⚠ | Experimental Computes `a + b`, while saturating at numeric bounds. The stabilized versions of this intrinsic are available on the integer primitives via the `saturating_add` method. For example, `std::u32::saturating_add`
saturating_sub⚠ | Experimental Computes `a - b`, while saturating at numeric bounds. The stabilized versions of this intrinsic are available on the integer primitives via the `saturating_sub` method. For example, `std::u32::saturating_sub`
sinf32⚠ | Experimental Returns the sine of an `f32`.
sinf64⚠ | Experimental Returns the sine of an `f64`.
size_of⚠ | Experimental The size of a type in bytes.
size_of_val⚠ | Experimental The size of the referenced value in bytes.
sqrtf32⚠ | Experimental Returns the square root of an `f32`
sqrtf64⚠ | Experimental Returns the square root of an `f64`
sub_with_overflow⚠ | Experimental Performs checked integer subtraction The stabilized versions of this intrinsic are available on the integer primitives via the `overflowing_sub` method. For example, `std::u32::overflowing_sub`
truncf32⚠ | Experimental Returns the integer part of an `f32`.
truncf64⚠ | Experimental Returns the integer part of an `f64`.
try⚠ | Experimental Rust's "try catch" construct which invokes the function pointer `f` with the data pointer `data`.
type_id⚠ | Experimental Gets an identifier which is globally unique to the specified type. This function will return the same value for a type regardless of whichever crate it is invoked in.
type_name⚠ | Experimental Gets a static string slice containing the name of a type.
unaligned_volatile_load⚠ | Experimental Performs a volatile load from the `src` pointer The pointer is not required to be aligned.
unaligned_volatile_store⚠ | Experimental Performs a volatile store to the `dst` pointer. The pointer is not required to be aligned.
unchecked_add⚠ | Experimental Returns the result of an unchecked addition, resulting in undefined behavior when `x + y > T::max_value()` or `x + y < T::min_value()`.
unchecked_div⚠ | Experimental Performs an unchecked division, resulting in undefined behavior where y = 0 or x = `T::min_value()` and y = -1
unchecked_mul⚠ | Experimental Returns the result of an unchecked multiplication, resulting in undefined behavior when `x * y > T::max_value()` or `x * y < T::min_value()`.
unchecked_rem⚠ | Experimental Returns the remainder of an unchecked division, resulting in undefined behavior where y = 0 or x = `T::min_value()` and y = -1
unchecked_shl⚠ | Experimental Performs an unchecked left shift, resulting in undefined behavior when y < 0 or y >= N, where N is the width of T in bits.
unchecked_shr⚠ | Experimental Performs an unchecked right shift, resulting in undefined behavior when y < 0 or y >= N, where N is the width of T in bits.
unchecked_sub⚠ | Experimental Returns the result of an unchecked substraction, resulting in undefined behavior when `x - y > T::max_value()` or `x - y < T::min_value()`.
uninit⚠ | DeprecatedExperimental Creates an uninitialized value.
unlikely⚠ | Experimental Hints to the compiler that branch condition is likely to be false. Returns the value passed to it.
unreachable⚠ | Experimental Tells LLVM that this point in the code is not reachable, enabling further optimizations.
volatile_copy_memory⚠ | Experimental Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with a size of `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
volatile_copy_nonoverlapping_memory⚠ | Experimental Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with a size of `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`
volatile_load⚠ | Experimental Performs a volatile load from the `src` pointer. The stabilized version of this intrinsic is `std::ptr::read_volatile`.
volatile_set_memory⚠ | Experimental Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a size of `count` * `size_of::<T>()` and an alignment of `min_align_of::<T>()`.
volatile_store⚠ | Experimental Performs a volatile store to the `dst` pointer. The stabilized version of this intrinsic is `std::ptr::write_volatile`.

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)