W3cubDocs

/Rust

Module std::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.

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.
drop_in_place ^⚠	Executes the destructor (if any) of the pointed-to value.
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 ^⚠	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`.
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 2^N, 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 2^N, 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 2^N, 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 ^⚠	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 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`.

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/intrinsics/index.html