Module core::intrinsics
source · [−]core_intrinsics)Expand description
Compiler intrinsics.
The corresponding definitions are in https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/intrinsic.rs. The corresponding const implementations are in https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/intrinsics.rs.
Const intrinsics
Note: any changes to the constness of intrinsics should be discussed with the language team. This includes changes in the stability of the constness.
In order to make an intrinsic usable at compile-time, one needs to copy the implementation
from https://github.com/rust-lang/miri/blob/master/src/shims/intrinsics.rs to
https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/intrinsics.rs and add a
#[rustc_const_unstable(feature = "const_such_and_such", issue = "01234")] to the intrinsic declaration.
If an intrinsic is supposed to be used from a const fn with a rustc_const_stable attribute,
the intrinsic’s attribute must be rustc_const_stable, too. Such a change should not be done
without T-lang consultation, because it bakes a feature into the language that cannot be
replicated in user code without compiler support.
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 super::atomic_cxchg_acqrel_acquire as atomic_cxchg_acqrel;pub use super::atomic_cxchg_acqrel_relaxed as atomic_cxchg_acqrel_failrelaxed;pub use super::atomic_cxchg_acquire_acquire as atomic_cxchg_acq;pub use super::atomic_cxchg_acquire_relaxed as atomic_cxchg_acq_failrelaxed;pub use super::atomic_cxchg_relaxed_relaxed as atomic_cxchg_relaxed;pub use super::atomic_cxchg_release_relaxed as atomic_cxchg_rel;pub use super::atomic_cxchg_seqcst_acquire as atomic_cxchg_failacq;pub use super::atomic_cxchg_seqcst_relaxed as atomic_cxchg_failrelaxed;pub use super::atomic_cxchg_seqcst_seqcst as atomic_cxchg;pub use super::atomic_store_seqcst as atomic_store;Functions
Aborts the execution of the process.
Performs checked integer addition.
Calculates the offset from a pointer, potentially wrapping.
A guard for unsafe functions that cannot ever be executed if T is uninhabited:
This will statically either panic, or do nothing.
A guard for unsafe functions that cannot ever be executed if T has invalid
bit patterns: This will statically either panic, or do nothing.
A guard for unsafe functions that cannot ever be executed if T does not permit
zero-initialization: This will statically either panic, or do nothing.
Informs the optimizer that a condition is always true. If the condition is false, the behavior is undefined.
Bitwise and with the current value, returning the previous value.
Bitwise and with the current value, returning the previous value.
Bitwise and with the current value, returning the previous value.
Bitwise and with the current value, returning the previous value.
Bitwise and with the current value, returning the previous value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
Stores a value if the current value is the same as the old value.
An atomic fence.
An atomic fence.
An atomic fence.
An atomic fence.
Loads the current value of the pointer.
Loads the current value of the pointer.
Loads the current value of the pointer.
Maximum with the current value using a signed comparison.
Maximum with the current value using a signed comparison.
Maximum with the current value.
Maximum with the current value using a signed comparison.
Maximum with the current value using a signed comparison.
Minimum with the current value using a signed comparison.
Minimum with the current value using a signed comparison.
Minimum with the current value using a signed comparison.
Minimum with the current value using a signed comparison.
Minimum with the current value using a signed comparison.
Bitwise nand with the current value, returning the previous value.
Bitwise nand with the current value, returning the previous value.
Bitwise nand with the current value, returning the previous value.
Bitwise nand with the current value, returning the previous value.
Bitwise nand with the current value, returning the previous value.
Bitwise or with the current value, returning the previous value.
Bitwise or with the current value, returning the previous value.
Bitwise or with the current value, returning the previous value.
Bitwise or with the current value, returning the previous value.
Bitwise or with the current value, returning the previous value.
A compiler-only memory barrier.
A compiler-only memory barrier.
A compiler-only memory barrier.
A compiler-only memory barrier.
Stores the value at the specified memory location.
Stores the value at the specified memory location.
Stores the value at the specified memory location.
Maximum with the current value using an unsigned comparison.
Maximum with the current value using an unsigned comparison.
Maximum with the current value using an unsigned comparison.
Maximum with the current value using an unsigned comparison.
Maximum with the current value using an unsigned comparison.
Minimum with the current value using an unsigned comparison.
Minimum with the current value using an unsigned comparison.
Minimum with the current value using an unsigned comparison.
Minimum with the current value using an unsigned comparison.
Minimum with the current value using an unsigned comparison.
Adds to the current value, returning the previous value.
Adds to the current value, returning the previous value.
Adds to the current value, returning the previous value.
Adds to the current value, returning the previous value.
Adds to the current value, returning the previous value.
Stores the value at the specified memory location, returning the old value.
Stores the value at the specified memory location, returning the old value.
Stores the value at the specified memory location, returning the old value.
Stores the value at the specified memory location, returning the old value.
Stores the value at the specified memory location, returning the old value.
Bitwise xor with the current value, returning the previous value.
Bitwise xor with the current value, returning the previous value.
Bitwise xor with the current value, returning the previous value.
Bitwise xor with the current value, returning the previous value.
Bitwise xor with the current value, returning the previous value.
Subtract from the current value, returning the previous value.
Subtract from the current value, returning the previous value.
Subtract from the current value, returning the previous value.
Subtract from the current value, returning the previous value.
Subtract from the current value, returning the previous value.
Reverses the bits in an integer type T.
See documentation of std::hint::black_box for details.
Executes a breakpoint trap, for inspection by a debugger.
Reverses the bytes in an integer type T.
Gets a reference to a static Location indicating where it was called.
Allocates a block of memory at compile time. At runtime, just returns a null pointer.
Deallocates a memory which allocated by intrinsics::const_allocate at compile time.
At runtime, does nothing.
Selects which function to call depending on the context.
Copies the sign from y to x for f32 values.
Copies the sign from y to x for f64 values.
Returns the number of leading unset bits (zeroes) in an integer type T.
Like ctlz, but extra-unsafe as it returns undef when
given an x with value 0.
Returns the number of bits set in an integer type T
Returns the number of trailing unset bits (zeroes) in an integer type T.
Like cttz, but extra-unsafe as it returns undef when
given an x with value 0.
Returns the value of the discriminant for the variant in ‘v’;
if T has no discriminant, returns 0.
Performs an exact division, resulting in undefined behavior where
x % y != 0 or y == 0 or x == T::MIN && y == -1
Float addition that allows optimizations based on algebraic rules. May assume inputs are finite.
Float division that allows optimizations based on algebraic rules. May assume inputs are finite.
Convert with LLVM’s fptoui/fptosi, which may return undef for values out of range (https://github.com/rust-lang/rust/issues/10184)
Float multiplication that allows optimizations based on algebraic rules. May assume inputs are finite.
Moves a value out of scope without running drop glue.
Float remainder that allows optimizations based on algebraic rules. May assume inputs are finite.
Float subtraction that allows optimizations based on algebraic rules. May assume inputs are finite.
Hints to the compiler that branch condition is likely to be true. Returns the value passed to it.
Returns the maximum of two f32 values.
Returns the maximum of two f64 values.
The minimum alignment of a type.
The required alignment of the referenced value.
Returns the minimum of two f32 values.
Returns the minimum of two f64 values.
Performs checked integer multiplication
Returns the nearest integer to an f32.
Returns the nearest integer to an f64.
Returns true if the actual type given as T requires drop
glue; returns false if the actual type provided for T
implements Copy.
Emits a !nontemporal store according to LLVM (see their docs).
Probably will never become stable.
The preferred alignment of a type.
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.
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.
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.
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.
See documentation of <*const T>::guaranteed_eq for details.
See documentation of <*const T>::guaranteed_ne for details.
See documentation of <*const T>::offset_from for details.
See documentation of <*const T>::sub_ptr for details.
Returns the nearest integer to an f32. May raise an inexact floating-point exception
if the argument is not an integer.
Returns the nearest integer to an f64. May raise an inexact floating-point exception
if the argument is not an integer.
Performs rotate left.
Performs rotate right.
Magic intrinsic that derives its meaning from attributes attached to the function.
Computes a + b, saturating at numeric bounds.
Computes a - b, saturating at numeric bounds.
The size of a type in bytes.
The size of the referenced value in bytes.
Performs checked integer subtraction
Rust’s “try catch” construct which invokes the function pointer try_fn
with the data pointer data.
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.
Gets a static string slice containing the name of a type.
Performs a volatile load from the src pointer
The pointer is not required to be aligned.
Performs a volatile store to the dst pointer.
The pointer is not required to be aligned.
Returns the result of an unchecked addition, resulting in
undefined behavior when x + y > T::MAX or x + y < T::MIN.
Performs an unchecked division, resulting in undefined behavior
where y == 0 or x == T::MIN && y == -1
Returns the result of an unchecked multiplication, resulting in
undefined behavior when x * y > T::MAX or x * y < T::MIN.
Returns the remainder of an unchecked division, resulting in
undefined behavior when y == 0 or x == T::MIN && y == -1
Performs an unchecked left shift, resulting in undefined behavior when
y < 0 or y >= N, where N is the width of T in bits.
Performs an unchecked right shift, resulting in undefined behavior when
y < 0 or y >= N, where N is the width of T in bits.
Returns the result of an unchecked subtraction, resulting in
undefined behavior when x - y > T::MAX or x - y < T::MIN.
Hints to the compiler that branch condition is likely to be false. Returns the value passed to it.
Informs the optimizer that this point in the code is not reachable, enabling further optimizations.
Returns the number of variants of the type T cast to a usize;
if T has no variants, returns 0. Uninhabited variants will be counted.
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>()
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>()
Performs a volatile load from the src pointer.
Equivalent to the appropriate llvm.memset.p0i8.* intrinsic, with a
size of count * size_of::<T>() and an alignment of
min_align_of::<T>().
Performs a volatile store to the dst pointer.
ptr must point to a vtable.
The intrinsic will return the alignment stored in that vtable.
ptr must point to a vtable.
The intrinsic will return the size stored in that vtable.
Returns (a + b) mod 2N, where N is the width of T in bits.
Returns (a * b) mod 2N, where N is the width of T in bits.
Returns (a - b) mod 2N, where N is the width of T in bits.
Copies count * size_of::<T>() bytes from src to dst. The source
and destination must not overlap.
Sets count * size_of::<T>() bytes of memory starting at dst to
val.