# [−][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

rustc 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 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 ] 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_acq⚠ | [ Experimental ] 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_acqrel⚠ | [ Experimental ] 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_rel⚠ | [ Experimental ] 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` as the `order`. For example, `AtomicIsize::fetch_add`.
atomic_xadd_relaxed⚠ | [ Experimental ] 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` 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⚠ | [ Experimental ] 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`.
min_align_of⚠ | [ Experimental ]
min_align_of_val⚠ | [ Experimental ]
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 noop. 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 noop. 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 noop. 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 noop. 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.
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 ] Perform a volatile load from the `src` pointer The pointer is not required to be aligned.
unaligned_volatile_store⚠ | [ Experimental ] Perform a volatile store to the `dst` pointer. The pointer is not required to be aligned.
unchecked_div⚠ | [ Experimental ] Performs an unchecked division, resulting in undefined behavior where y = 0 or x = `T::min_value()` and y = -1
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.
uninit⚠ | [ Experimental ] 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 ] Perform 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 ] Perform 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`)