Module std::intrinsics[−][src]

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

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:

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 may 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⚠

Invokes memset on the specified pointer, setting 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.
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
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.
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.
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.