Module core::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:

Re-exports

pub use ptr::drop_in_place;

Functions

copy

Copies count * size_of<T> bytes from src to dst. The source and destination may overlap.

copy_nonoverlapping

Copies count * size_of<T> bytes from src to dst. The source and destination may not overlap.

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.

unaligned_volatile_load [
Experimental
]

Perform a volatile load from the src pointer The pointer is not required to be aligned.

unaligned_volatile_store [
Experimental
]

Perform a volatile store to the dst pointer. The pointer is not required to be aligned.

unchecked_div [
Experimental
]

Performs an unchecked division, resulting in undefined behavior where y = 0 or x = T::min_value() and y = -1

unchecked_rem [
Experimental
]

Returns the remainder of an unchecked division, resulting in undefined behavior where y = 0 or x = T::min_value() and y = -1

unchecked_shl [
Experimental
]

Performs an unchecked left shift, resulting in undefined behavior when y < 0 or y >= N, where N is the width of T in bits.

unchecked_shr [
Experimental
]

Performs an unchecked right shift, resulting in undefined behavior when y < 0 or y >= N, where N is the width of T in bits.

uninit [
Experimental
]

Creates an uninitialized value.

unlikely [
Experimental
]

Hints to the compiler that branch condition is likely to be false. Returns the value passed to it.

unreachable [
Experimental
]

Tells LLVM that this point in the code is not reachable, enabling further optimizations.

volatile_copy_memory [
Experimental
]

Equivalent to the appropriate llvm.memmove.p0i8.0i8.* intrinsic, with a size of count * size_of::<T>() and an alignment of min_align_of::<T>()

volatile_copy_nonoverlapping_memory [
Experimental
]

Equivalent to the appropriate llvm.memcpy.p0i8.0i8.* intrinsic, with a size of count * size_of::<T>() and an alignment of min_align_of::<T>()

volatile_load [
Experimental
]

Perform a volatile load from the src pointer. The stabilized version of this intrinsic is std::ptr::read_volatile.

volatile_set_memory [
Experimental
]

Equivalent to the appropriate llvm.memset.p0i8.* intrinsic, with a size of count * size_of::<T>() and an alignment of min_align_of::<T>().

volatile_store [
Experimental
]

Perform a volatile store to the dst pointer. The stabilized version of this intrinsic is std::ptr::write_volatile.