core::intrinsics - Rust
Description: Compiler intrinsics.

# Module intrinsics

Source
🔬This is a nightly-only experimental API. (`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

In order to make an intrinsic unstable usable at compile-time, copy the implementation from https://github.com/rust-lang/miri/blob/master/src/intrinsics to https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/intrinsics.rs and make the intrinsic declaration below a `const fn`. This should be done in coordination with wg-const-eval.

If an intrinsic is supposed to be used from a `const fn` with a `rustc_const_stable` attribute, `#[rustc_intrinsic_const_stable_indirect]` needs to be added to the intrinsic. Such a change requires T-lang approval, because it may bake 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`.

## §Unwinding

Rust intrinsics may, in general, unwind. If an intrinsic can never unwind, add the `#[rustc_nounwind]` attribute so that the compiler can make use of this fact.

However, even for intrinsics that may unwind, rustc assumes that a Rust intrinsics will never initiate a foreign (non-Rust) unwind, and thus for panic=abort we can always assume that these intrinsics cannot unwind.

## Modules§

fallbackExperimental
mirExperimental
  Rustc internal tooling for hand-writing MIR.
simdExperimental
  SIMD compiler intrinsics.

## Traits§

AggregateRawPtrExperimental

## Functions§

copy⚠Deprecated
  Copies `count * size_of::<T>()` bytes from `src` to `dst`. The source and destination may overlap.
copy_nonoverlapping⚠Deprecated
  Copies `count * size_of::<T>()` bytes from `src` to `dst`. The source and destination must not overlap.
drop_in_place⚠Deprecated
transmute⚠Deprecated
  Reinterprets the bits of a value of one type as another type.
write_bytes⚠Deprecated
  Sets `count * size_of::<T>()` bytes of memory starting at `dst` to `val`.
abortExperimental
  Aborts the execution of the process.
add_with_overflowExperimental
  Performs checked integer addition.
aggregate_raw_ptrExperimental
  Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`.
arith_offset⚠Experimental
  Calculates the offset from a pointer, potentially wrapping.
assert_inhabitedExperimental
  A guard for unsafe functions that cannot ever be executed if `T` is uninhabited: This will statically either panic, or do nothing.
assert_mem_uninitialized_validExperimental
  A guard for `std::mem::uninitialized`. This will statically either panic, or do nothing.
assert_zero_validExperimental
  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.
assume⚠Experimental
  Informs the optimizer that a condition is always true. If the condition is false, the behavior is undefined.
atomic_and_acqrel⚠Experimental
  Bitwise and with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_and_acquire⚠Experimental
  Bitwise and with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_and_relaxed⚠Experimental
  Bitwise and with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_and_release⚠Experimental
  Bitwise and with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_and_seqcst⚠Experimental
  Bitwise and with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_cxchg_acqrel_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_acqrel_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_acqrel_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_acquire_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_acquire_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_acquire_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_relaxed_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_relaxed_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_relaxed_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_release_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_release_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_release_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_seqcst_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_seqcst_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchg_seqcst_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_acqrel_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_acqrel_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_acqrel_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_acquire_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_acquire_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_acquire_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_relaxed_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_relaxed_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_relaxed_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_release_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_release_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_release_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_seqcst_acquire⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_seqcst_relaxed⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_cxchgweak_seqcst_seqcst⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type.
atomic_fence_acqrel⚠Experimental
  An atomic fence.
atomic_fence_acquire⚠Experimental
  An atomic fence.
atomic_fence_release⚠Experimental
  An atomic fence.
atomic_fence_seqcst⚠Experimental
  An atomic fence.
atomic_load_acquire⚠Experimental
  Loads the current value of the pointer. `T` must be an integer or pointer type.
atomic_load_relaxed⚠Experimental
  Loads the current value of the pointer. `T` must be an integer or pointer type.
atomic_load_seqcst⚠Experimental
  Loads the current value of the pointer. `T` must be an integer or pointer type.
atomic_load_unordered⚠Experimental
  Do NOT use this intrinsic; “unordered” operations do not exist in our memory model! In terms of the Rust Abstract Machine, this operation is equivalent to `src.read()`, i.e., it performs a non-atomic read.
atomic_max_acqrel⚠Experimental
  Maximum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_max_acquire⚠Experimental
  Maximum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_max_relaxed⚠Experimental
  Maximum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_max_release⚠Experimental
  Maximum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_max_seqcst⚠Experimental
  Maximum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_min_acqrel⚠Experimental
  Minimum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_min_acquire⚠Experimental
  Minimum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_min_relaxed⚠Experimental
  Minimum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_min_release⚠Experimental
  Minimum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_min_seqcst⚠Experimental
  Minimum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_nand_acqrel⚠Experimental
  Bitwise nand with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_nand_acquire⚠Experimental
  Bitwise nand with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_nand_relaxed⚠Experimental
  Bitwise nand with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_nand_release⚠Experimental
  Bitwise nand with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_nand_seqcst⚠Experimental
  Bitwise nand with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_or_acqrel⚠Experimental
  Bitwise or with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_or_acquire⚠Experimental
  Bitwise or with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_or_relaxed⚠Experimental
  Bitwise or with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_or_release⚠Experimental
  Bitwise or with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_or_seqcst⚠Experimental
  Bitwise or with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_singlethreadfence_acqrel⚠Experimental
  A compiler-only memory barrier.
atomic_singlethreadfence_acquire⚠Experimental
  A compiler-only memory barrier.
atomic_singlethreadfence_release⚠Experimental
  A compiler-only memory barrier.
atomic_singlethreadfence_seqcst⚠Experimental
  A compiler-only memory barrier.
atomic_store_relaxed⚠Experimental
  Stores the value at the specified memory location. `T` must be an integer or pointer type.
atomic_store_release⚠Experimental
  Stores the value at the specified memory location. `T` must be an integer or pointer type.
atomic_store_seqcst⚠Experimental
  Stores the value at the specified memory location. `T` must be an integer or pointer type.
atomic_store_unordered⚠Experimental
  Do NOT use this intrinsic; “unordered” operations do not exist in our memory model! In terms of the Rust Abstract Machine, this operation is equivalent to `dst.write(val)`, i.e., it performs a non-atomic write.
atomic_umax_acqrel⚠Experimental
  Maximum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umax_acquire⚠Experimental
  Maximum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umax_relaxed⚠Experimental
  Maximum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umax_release⚠Experimental
  Maximum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umax_seqcst⚠Experimental
  Maximum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umin_acqrel⚠Experimental
  Minimum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umin_acquire⚠Experimental
  Minimum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umin_relaxed⚠Experimental
  Minimum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umin_release⚠Experimental
  Minimum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umin_seqcst⚠Experimental
  Minimum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_xadd_acqrel⚠Experimental
  Adds to the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xadd_acquire⚠Experimental
  Adds to the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xadd_relaxed⚠Experimental
  Adds to the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xadd_release⚠Experimental
  Adds to the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xadd_seqcst⚠Experimental
  Adds to the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xchg_acqrel⚠Experimental
  Stores the value at the specified memory location, returning the old value. `T` must be an integer or pointer type.
atomic_xchg_acquire⚠Experimental
  Stores the value at the specified memory location, returning the old value. `T` must be an integer or pointer type.
atomic_xchg_relaxed⚠Experimental
  Stores the value at the specified memory location, returning the old value. `T` must be an integer or pointer type.
atomic_xchg_release⚠Experimental
  Stores the value at the specified memory location, returning the old value. `T` must be an integer or pointer type.
atomic_xchg_seqcst⚠Experimental
  Stores the value at the specified memory location, returning the old value. `T` must be an integer or pointer type.
atomic_xor_acqrel⚠Experimental
  Bitwise xor with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xor_acquire⚠Experimental
  Bitwise xor with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xor_relaxed⚠Experimental
  Bitwise xor with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xor_release⚠Experimental
  Bitwise xor with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xor_seqcst⚠Experimental
  Bitwise xor with the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xsub_acqrel⚠Experimental
  Subtract from the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xsub_acquire⚠Experimental
  Subtract from the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xsub_relaxed⚠Experimental
  Subtract from the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xsub_release⚠Experimental
  Subtract from the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
atomic_xsub_seqcst⚠Experimental
  Subtract from the current value, returning the previous value. `T` must be an integer or pointer type. If `T` is a pointer type, the provenance of `src` is ignored: both the return value and the new value stored at `*dst` will have the provenance of the old value stored there.
bitreverseExperimental
  Reverses the bits in an integer type `T`.
black_boxExperimental
  See documentation of `std::hint::black_box` for details.
breakpointExperimental
  Executes a breakpoint trap, for inspection by a debugger.
bswapExperimental
  Reverses the bytes in an integer type `T`.
caller_locationExperimental
  Gets a reference to a static `Location` indicating where it was called.
carrying_mul_addExperimental
  Performs full-width multiplication and addition with a carry: `multiplier * multiplicand + addend + carry`.
catch_unwind⚠Experimental
  Rust’s “try catch” construct for unwinding. Invokes the function pointer `try_fn` with the data pointer `data`, and calls `catch_fn` if unwinding occurs while `try_fn` runs. Returns `1` if unwinding occurred and `catch_fn` was called; returns `0` otherwise.
ceilf16⚠Experimental
  Returns the smallest integer greater than or equal to an `f16`.
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`.
ceilf128⚠Experimental
  Returns the smallest integer greater than or equal to an `f128`.
cold_pathExperimental
  Hints to the compiler that current code path is cold.
compare_bytes⚠Experimental
  Lexicographically compare `[left, left + bytes)` and `[right, right + bytes)` as unsigned bytes, returning negative if `left` is less, zero if all the bytes match, or positive if `left` is greater.
const_allocate⚠Experimental
  Allocates a block of memory at compile time. At runtime, just returns a null pointer.
const_deallocate⚠Experimental
  Deallocates a memory which allocated by `intrinsics::const_allocate` at compile time. At runtime, does nothing.
const_eval_selectExperimental
  Selects which function to call depending on the context.
contract_check_ensuresExperimental
  Check if the post-condition `cond` has been met.
contract_check_requiresExperimental
  Check if the pre-condition `cond` has been met.
contract_checksExperimental
  Returns whether we should perform contract-checking at runtime.
copysignf16⚠Experimental
  Copies the sign from `y` to `x` for `f16` values.
copysignf32⚠Experimental
  Copies the sign from `y` to `x` for `f32` values.
copysignf64⚠Experimental
  Copies the sign from `y` to `x` for `f64` values.
copysignf128⚠Experimental
  Copies the sign from `y` to `x` for `f128` values.
cosf16⚠Experimental
  Returns the cosine of an `f16`.
cosf32⚠Experimental
  Returns the cosine of an `f32`.
cosf64⚠Experimental
  Returns the cosine of an `f64`.
cosf128⚠Experimental
  Returns the cosine of an `f128`.
ctlzExperimental
  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`.
ctpopExperimental
  Returns the number of bits set in an integer type `T`
cttzExperimental
  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_valueExperimental
  Returns the value of the discriminant for the variant in ‘v’; if `T` has no discriminant, returns `0`.
disjoint_bitor⚠Experimental
  Combine two values which have no bits in common.
exact_div⚠Experimental
  Performs an exact division, resulting in undefined behavior where `x % y != 0` or `y == 0` or `x == T::MIN && y == -1`
exp2f16⚠Experimental
  Returns 2 raised to the power of an `f16`.
exp2f32⚠Experimental
  Returns 2 raised to the power of an `f32`.
exp2f64⚠Experimental
  Returns 2 raised to the power of an `f64`.
exp2f128⚠Experimental
  Returns 2 raised to the power of an `f128`.
expf16⚠Experimental
  Returns the exponential of an `f16`.
expf32⚠Experimental
  Returns the exponential of an `f32`.
expf64⚠Experimental
  Returns the exponential of an `f64`.
expf128⚠Experimental
  Returns the exponential of an `f128`.
fabsf16⚠Experimental
  Returns the absolute value of an `f16`.
fabsf32⚠Experimental
  Returns the absolute value of an `f32`.
fabsf64⚠Experimental
  Returns the absolute value of an `f64`.
fabsf128⚠Experimental
  Returns the absolute value of an `f128`.
fadd_algebraicExperimental
  Float addition that allows optimizations based on algebraic rules.
fadd_fast⚠Experimental
  Float addition that allows optimizations based on algebraic rules. May assume inputs are finite.
fdiv_algebraicExperimental
  Float division that allows optimizations based on algebraic rules.
fdiv_fast⚠Experimental
  Float division that allows optimizations based on algebraic rules. May assume inputs are finite.
float_to_int_unchecked⚠Experimental
  Converts with LLVM’s fptoui/fptosi, which may return undef for values out of range (https://github.com/rust-lang/rust/issues/10184)
floorf16⚠Experimental
  Returns the largest integer less than or equal to an `f16`.
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`.
floorf128⚠Experimental
  Returns the largest integer less than or equal to an `f128`.
fmaf16⚠Experimental
  Returns `a * b + c` for `f16` values.
fmaf32⚠Experimental
  Returns `a * b + c` for `f32` values.
fmaf64⚠Experimental
  Returns `a * b + c` for `f64` values.
fmaf128⚠Experimental
  Returns `a * b + c` for `f128` values.
fmul_algebraicExperimental
  Float multiplication that allows optimizations based on algebraic rules.
fmul_fast⚠Experimental
  Float multiplication that allows optimizations based on algebraic rules. May assume inputs are finite.
fmuladdf16⚠Experimental
  Returns `a * b + c` for `f16` values, non-deterministically executing either a fused multiply-add or two operations with rounding of the intermediate result.
fmuladdf32⚠Experimental
  Returns `a * b + c` for `f32` values, non-deterministically executing either a fused multiply-add or two operations with rounding of the intermediate result.
fmuladdf64⚠Experimental
  Returns `a * b + c` for `f64` values, non-deterministically executing either a fused multiply-add or two operations with rounding of the intermediate result.
fmuladdf128⚠Experimental
  Returns `a * b + c` for `f128` values, non-deterministically executing either a fused multiply-add or two operations with rounding of the intermediate result.
forgetExperimental
  Moves a value out of scope without running drop glue.
frem_algebraicExperimental
  Float remainder that allows optimizations based on algebraic rules.
frem_fast⚠Experimental
  Float remainder that allows optimizations based on algebraic rules. May assume inputs are finite.
fsub_algebraicExperimental
  Float subtraction that allows optimizations based on algebraic rules.
fsub_fast⚠Experimental
  Float subtraction that allows optimizations based on algebraic rules. May assume inputs are finite.
is_val_statically_knownExperimental
  Returns whether the argument’s value is statically known at compile-time.
likelyExperimental
  Hints to the compiler that branch condition is likely to be true. Returns the value passed to it.
log2f16⚠Experimental
  Returns the base 2 logarithm of an `f16`.
log2f32⚠Experimental
  Returns the base 2 logarithm of an `f32`.
log2f64⚠Experimental
  Returns the base 2 logarithm of an `f64`.
log2f128⚠Experimental
  Returns the base 2 logarithm of an `f128`.
log10f16⚠Experimental
  Returns the base 10 logarithm of an `f16`.
log10f32⚠Experimental
  Returns the base 10 logarithm of an `f32`.
log10f64⚠Experimental
  Returns the base 10 logarithm of an `f64`.
log10f128⚠Experimental
  Returns the base 10 logarithm of an `f128`.
logf16⚠Experimental
  Returns the natural logarithm of an `f16`.
logf32⚠Experimental
  Returns the natural logarithm of an `f32`.
logf64⚠Experimental
  Returns the natural logarithm of an `f64`.
logf128⚠Experimental
  Returns the natural logarithm of an `f128`.
maxnumf16Experimental
  Returns the maximum of two `f16` values.
maxnumf32Experimental
  Returns the maximum of two `f32` values.
maxnumf64Experimental
  Returns the maximum of two `f64` values.
maxnumf128Experimental
  Returns the maximum of two `f128` values.
min_align_ofExperimental
  The minimum alignment of a type.
min_align_of_val⚠Experimental
  The required alignment of the referenced value.
minnumf16Experimental
  Returns the minimum of two `f16` values.
minnumf32Experimental
  Returns the minimum of two `f32` values.
minnumf64Experimental
  Returns the minimum of two `f64` values.
minnumf128Experimental
  Returns the minimum of two `f128` values.
mul_with_overflowExperimental
  Performs checked integer multiplication
needs_dropExperimental
  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, which gives a hint to the CPU that the data should not be held in cache. Except for performance, this is fully equivalent to `ptr.write(val)`.
offset⚠Experimental
  Calculates the offset from a pointer.
powf16⚠Experimental
  Raises an `f16` to an `f16` power.
powf32⚠Experimental
  Raises an `f32` to an `f32` power.
powf64⚠Experimental
  Raises an `f64` to an `f64` power.
powf128⚠Experimental
  Raises an `f128` to an `f128` power.
powif16⚠Experimental
  Raises an `f16` to an integer power.
powif32⚠Experimental
  Raises an `f32` to an integer power.
powif64⚠Experimental
  Raises an `f64` to an integer power.
powif128⚠Experimental
  Raises an `f128` to an integer power.
pref_align_of⚠Experimental
  The preferred alignment of a type.
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.
ptr_guaranteed_cmpExperimental
  See documentation of `<*const T>::guaranteed_eq` for details. Returns `2` if the result is unknown. Returns `1` if the pointers are guaranteed equal. Returns `0` if the pointers are guaranteed inequal.
ptr_maskExperimental
  Masks out bits of the pointer according to a mask.
ptr_metadataExperimental
  Lowers in MIR to `Rvalue::UnaryOp` with `UnOp::PtrMetadata`.
ptr_offset_from⚠Experimental
  See documentation of `<*const T>::offset_from` for details.
ptr_offset_from_unsigned⚠Experimental
  See documentation of `<*const T>::offset_from_unsigned` for details.
raw_eq⚠Experimental
  Determines whether the raw bytes of the two values are equal.
read_via_copy⚠Experimental
  This is an implementation detail of `crate::ptr::read` and should not be used anywhere else. See its comments for why this exists.
rintf32⚠Experimental
  Provided for compatibility with stdarch. DO NOT USE.
rintf64⚠Experimental
  Provided for compatibility with stdarch. DO NOT USE.
rotate_leftExperimental
  Performs rotate left.
rotate_rightExperimental
  Performs rotate right.
round_ties_even_f16Experimental
  Returns the nearest integer to an `f16`. Rounds half-way cases to the number with an even least significant digit.
round_ties_even_f32Experimental
  Returns the nearest integer to an `f32`. Rounds half-way cases to the number with an even least significant digit.
round_ties_even_f64Experimental
  Returns the nearest integer to an `f64`. Rounds half-way cases to the number with an even least significant digit.
round_ties_even_f128Experimental
  Returns the nearest integer to an `f128`. Rounds half-way cases to the number with an even least significant digit.
roundf16⚠Experimental
  Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
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.
roundf128⚠Experimental
  Returns the nearest integer to an `f128`. Rounds half-way cases away from zero.
rustc_peekExperimental
  Magic intrinsic that derives its meaning from attributes attached to the function.
saturating_addExperimental
  Computes `a + b`, saturating at numeric bounds.
saturating_subExperimental
  Computes `a - b`, saturating at numeric bounds.
select_unpredictableExperimental
  Returns either `true_val` or `false_val` depending on condition `b` with a hint to the compiler that this condition is unlikely to be correctly predicted by a CPU’s branch predictor (e.g. a binary search).
sinf16⚠Experimental
  Returns the sine of an `f16`.
sinf32⚠Experimental
  Returns the sine of an `f32`.
sinf64⚠Experimental
  Returns the sine of an `f64`.
sinf128⚠Experimental
  Returns the sine of an `f128`.
size_ofExperimental
  The size of a type in bytes.
size_of_val⚠Experimental
  The size of the referenced value in bytes.
sqrtf16⚠Experimental
  Returns the square root of an `f16`
sqrtf32⚠Experimental
  Returns the square root of an `f32`
sqrtf64⚠Experimental
  Returns the square root of an `f64`
sqrtf128⚠Experimental
  Returns the square root of an `f128`
sub_with_overflowExperimental
  Performs checked integer subtraction
three_way_compareExperimental
  Does a three-way comparison between the two arguments, which must be of character or integer (signed or unsigned) type.
transmute_unchecked⚠Experimental
  Like `transmute`, but even less checked at compile-time: rather than giving an error for `size_of::<Src>() != size_of::<Dst>()`, it’s Undefined Behavior at runtime.
truncf16⚠Experimental
  Returns the integer part of an `f16`.
truncf32⚠Experimental
  Returns the integer part of an `f32`.
truncf64⚠Experimental
  Returns the integer part of an `f64`.
truncf128⚠Experimental
  Returns the integer part of an `f128`.
type_idExperimental
  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_nameExperimental
  Gets a static string slice containing the name of a type.
typed_swap_nonoverlapping⚠Experimental
  Non-overlapping typed swap of a single value.
ub_checksExperimental
  Returns whether we should perform some UB-checking at runtime. This eventually evaluates to `cfg!(ub_checks)`, but behaves different from `cfg!` when mixing crates built with different flags: if the crate has UB checks enabled or carries the `#[rustc_preserve_ub_checks]` attribute, evaluation is delayed until monomorphization (or until the call gets inlined into a crate that does not delay evaluation further); otherwise it can happen any time.
unaligned_volatile_load⚠Experimental
  Performs a volatile load from the `src` pointer The pointer is not required to be aligned.
unaligned_volatile_store⚠Experimental
  Performs a volatile store to the `dst` pointer. The pointer is not required to be aligned.
unchecked_add⚠Experimental
  Returns the result of an unchecked addition, resulting in undefined behavior when `x + y > T::MAX` or `x + y < T::MIN`.
unchecked_div⚠Experimental
  Performs an unchecked division, resulting in undefined behavior where `y == 0` or `x == T::MIN && y == -1`
unchecked_mul⚠Experimental
  Returns the result of an unchecked multiplication, resulting in undefined behavior when `x * y > T::MAX` or `x * y < T::MIN`.
unchecked_rem⚠Experimental
  Returns the remainder of an unchecked division, resulting in undefined behavior when `y == 0` or `x == T::MIN && y == -1`
unchecked_shl⚠Experimental
  Performs an unchecked left shift, resulting in undefined behavior when `y < 0` or `y >= N`, where N is the width of T in bits.
unchecked_shr⚠Experimental
  Performs an unchecked right shift, resulting in undefined behavior when `y < 0` or `y >= N`, where N is the width of T in bits.
unchecked_sub⚠Experimental
  Returns the result of an unchecked subtraction, resulting in undefined behavior when `x - y > T::MAX` or `x - y < T::MIN`.
unlikelyExperimental
  Hints to the compiler that branch condition is likely to be false. Returns the value passed to it.
unreachable⚠Experimental
  Informs the optimizer that this point in the code is not reachable, enabling further optimizations.
variant_countExperimental
  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.
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.
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.
vtable_align⚠Experimental
  The intrinsic will return the alignment stored in that vtable.
vtable_size⚠Experimental
  The intrinsic will return the size stored in that vtable.
wrapping_addExperimental
  Returns (a + b) mod 2N, where N is the width of T in bits.
wrapping_mulExperimental
  Returns (a * b) mod 2N, where N is the width of T in bits.
wrapping_subExperimental
  Returns (a - b) mod 2N, where N is the width of T in bits.
write_via_move⚠Experimental
  This is an implementation detail of `crate::ptr::write` and should not be used anywhere else. See its comments for why this exists.