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⚠	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 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_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 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.