std::intrinsics - Rust
Description: Compiler intrinsics.

## Module intrinsics

Source
🔬This is a nightly-only experimental API. (`core_intrinsics`)
Expand description

Compiler intrinsics.

The functions in this module are implementation details of `core` and should not be used outside of the standard library. We generally provide access to intrinsics via stable wrapper functions. Use these instead.

These are the imports making intrinsics available to Rust code. The actual implementations live in the compiler. Some of these intrinsics are lowered to MIR in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_mir_transform/src/lower_intrinsics.rs. The remaining intrinsics are implemented for the LLVM backend in https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs and https://github.com/rust-lang/rust/blob/HEAD/compiler/rustc_codegen_llvm/src/intrinsic.rs, and for const evaluation in https://github.com/rust-lang/rust/blob/HEAD/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/HEAD/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 `read_volatile` and `write_volatile`.

## §Atomics

The atomic intrinsics provide common atomic operations on machine words, with multiple possible memory orderings. See the atomic types docs for details.

## §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
gpuExperimental
  Intrinsics for GPU targets.
mirExperimental
  Rustc internal tooling for hand-writing MIR.
simdExperimental
  SIMD compiler intrinsics.

## Enums§

AtomicOrderingExperimental
  A type for atomic ordering parameters for intrinsics. This is a separate type from `atomic::Ordering` so that we can make it `ConstParamTy` and fix the values used here without a risk of leaking that to stable code.

## Functions§

copy⚠Deprecated
  This is an accidentally-stable alias to `ptr::copy`; use that instead.
copy_nonoverlapping⚠Deprecated
  This is an accidentally-stable alias to `ptr::copy_nonoverlapping`; use that instead.
transmute⚠Deprecated
  Reinterprets the bits of a value of one type as another type.
write_bytes⚠Deprecated
  This is an accidentally-stable alias to `ptr::write_bytes`; use that instead.
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`.
align_ofExperimental
  The minimum alignment of a type.
align_of_val⚠Experimental
  The required alignment of the referenced value.
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. It does not guarantee to ever panic, and should only be called if an assertion failure will imply language UB in the following code.
assert_mem_uninitialized_validExperimental
  A guard for `std::mem::uninitialized`. This will statically either panic, or do nothing. It does not guarantee to ever panic, and should only be called if an assertion failure will imply language UB in the following code.
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. It does not guarantee to ever panic, and should only be called if an assertion failure will imply language UB in the following code.
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. `T` must be an integer or pointer type. `U` must be the same as `T` if that is an integer type, or `usize` if `T` is a pointer type.
atomic_cxchg⚠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⚠Experimental
  Stores a value if the current value is the same as the `old` value. `T` must be an integer or pointer type. The comparison may spuriously fail.
atomic_fence⚠Experimental
  An atomic fence.
atomic_load⚠Experimental
  Loads the current value of the pointer. `T` must be an integer or pointer type.
atomic_max⚠Experimental
  Maximum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_min⚠Experimental
  Minimum with the current value using a signed comparison. `T` must be a signed integer type.
atomic_nand⚠Experimental
  Bitwise nand with the current value, returning the previous value. `T` must be an integer or pointer type. `U` must be the same as `T` if that is an integer type, or `usize` if `T` is a pointer type.
atomic_or⚠Experimental
  Bitwise or with the current value, returning the previous value. `T` must be an integer or pointer type. `U` must be the same as `T` if that is an integer type, or `usize` if `T` is a pointer type.
atomic_singlethreadfence⚠Experimental
  An atomic fence for synchronization within a single thread.
atomic_store⚠Experimental
  Stores the value at the specified memory location. `T` must be an integer or pointer type.
atomic_umax⚠Experimental
  Maximum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_umin⚠Experimental
  Minimum with the current value using an unsigned comparison. `T` must be an unsigned integer type.
atomic_xadd⚠Experimental
  Adds to the current value, returning the previous value. `T` must be an integer or pointer type. `U` must be the same as `T` if that is an integer type, or `usize` if `T` is a pointer type.
atomic_xchg⚠Experimental
  Stores the value at the specified memory location, returning the old value. `T` must be an integer or pointer type.
atomic_xor⚠Experimental
  Bitwise xor with the current value, returning the previous value. `T` must be an integer or pointer type. `U` must be the same as `T` if that is an integer type, or `usize` if `T` is a pointer type.
atomic_xsub⚠Experimental
  Subtract from the current value, returning the previous value. `T` must be an integer or pointer type. `U` must be the same as `T` if that is an integer type, or `usize` if `T` is a pointer type.
autodiffExperimental
  Generates the LLVM body for the automatic differentiation of `f` using Enzyme, with `df` as the derivative function and `args` as its arguments.
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.
ceilf16Experimental
  Returns the smallest integer greater than or equal to an `f16`.
ceilf32Experimental
  Returns the smallest integer greater than or equal to an `f32`.
ceilf64Experimental
  Returns the smallest integer greater than or equal to an `f64`.
ceilf128Experimental
  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.
const_make_global⚠Experimental
contract_check_ensuresExperimental
  Check if the post-condition `cond` has been met.
contract_check_requiresExperimental
  Check if the pre-condition `cond` has been met.
copysignf16Experimental
  Copies the sign from `y` to `x` for `f16` values.
copysignf32Experimental
  Copies the sign from `y` to `x` for `f32` values.
copysignf64Experimental
  Copies the sign from `y` to `x` for `f64` values.
copysignf128Experimental
  Copies the sign from `y` to `x` for `f128` values.
cosf16Experimental
  Returns the cosine of an `f16`.
cosf32Experimental
  Returns the cosine of an `f32`.
cosf64Experimental
  Returns the cosine of an `f64`.
cosf128Experimental
  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`
exp2f16Experimental
  Returns 2 raised to the power of an `f16`.
exp2f32Experimental
  Returns 2 raised to the power of an `f32`.
exp2f64Experimental
  Returns 2 raised to the power of an `f64`.
exp2f128Experimental
  Returns 2 raised to the power of an `f128`.
expf16Experimental
  Returns the exponential of an `f16`.
expf32Experimental
  Returns the exponential of an `f32`.
expf64Experimental
  Returns the exponential of an `f64`.
expf128Experimental
  Returns the exponential of an `f128`.
fabsf16Experimental
  Returns the absolute value of an `f16`.
fabsf32Experimental
  Returns the absolute value of an `f32`.
fabsf64Experimental
  Returns the absolute value of an `f64`.
fabsf128Experimental
  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. Requires that inputs and output of the operation are finite, causing UB otherwise.
fdiv_algebraicExperimental
  Float division that allows optimizations based on algebraic rules.
fdiv_fast⚠Experimental
  Float division that allows optimizations based on algebraic rules. Requires that inputs and output of the operation are finite, causing UB otherwise.
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)
floorf16Experimental
  Returns the largest integer less than or equal to an `f16`.
floorf32Experimental
  Returns the largest integer less than or equal to an `f32`.
floorf64Experimental
  Returns the largest integer less than or equal to an `f64`.
floorf128Experimental
  Returns the largest integer less than or equal to an `f128`.
fmaf16Experimental
  Returns `a * b + c` for `f16` values.
fmaf32Experimental
  Returns `a * b + c` for `f32` values.
fmaf64Experimental
  Returns `a * b + c` for `f64` values.
fmaf128Experimental
  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. Requires that inputs and output of the operation are finite, causing UB otherwise.
fmuladdf16Experimental
  Returns `a * b + c` for `f16` values, non-deterministically executing either a fused multiply-add or two operations with rounding of the intermediate result.
fmuladdf32Experimental
  Returns `a * b + c` for `f32` values, non-deterministically executing either a fused multiply-add or two operations with rounding of the intermediate result.
fmuladdf64Experimental
  Returns `a * b + c` for `f64` values, non-deterministically executing either a fused multiply-add or two operations with rounding of the intermediate result.
fmuladdf128Experimental
  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. Requires that inputs and output of the operation are finite, causing UB otherwise.
fsub_algebraicExperimental
  Float subtraction that allows optimizations based on algebraic rules.
fsub_fast⚠Experimental
  Float subtraction that allows optimizations based on algebraic rules. Requires that inputs and output of the operation are finite, causing UB otherwise.
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.
log2f16Experimental
  Returns the base 2 logarithm of an `f16`.
log2f32Experimental
  Returns the base 2 logarithm of an `f32`.
log2f64Experimental
  Returns the base 2 logarithm of an `f64`.
log2f128Experimental
  Returns the base 2 logarithm of an `f128`.
log10f16Experimental
  Returns the base 10 logarithm of an `f16`.
log10f32Experimental
  Returns the base 10 logarithm of an `f32`.
log10f64Experimental
  Returns the base 10 logarithm of an `f64`.
log10f128Experimental
  Returns the base 10 logarithm of an `f128`.
logf16Experimental
  Returns the natural logarithm of an `f16`.
logf32Experimental
  Returns the natural logarithm of an `f32`.
logf64Experimental
  Returns the natural logarithm of an `f64`.
logf128Experimental
  Returns the natural logarithm of an `f128`.
maximumf16Experimental
  Returns the maximum of two `f16` values, propagating NaN.
maximumf32Experimental
  Returns the maximum of two `f32` values, propagating NaN.
maximumf64Experimental
  Returns the maximum of two `f64` values, propagating NaN.
maximumf128Experimental
  Returns the maximum of two `f128` values, propagating NaN.
maxnumf16Experimental
  Returns the maximum of two `f16` values, ignoring NaN.
maxnumf32Experimental
  Returns the maximum of two `f32` values, ignoring NaN.
maxnumf64Experimental
  Returns the maximum of two `f64` values, ignoring NaN.
maxnumf128Experimental
  Returns the maximum of two `f128` values, ignoring NaN.
minimumf16Experimental
  Returns the minimum of two `f16` values, propagating NaN.
minimumf32Experimental
  Returns the minimum of two `f32` values, propagating NaN.
minimumf64Experimental
  Returns the minimum of two `f64` values, propagating NaN.
minimumf128Experimental
  Returns the minimum of two `f128` values, propagating NaN.
minnumf16Experimental
  Returns the minimum of two `f16` values, ignoring NaN.
minnumf32Experimental
  Returns the minimum of two `f32` values, ignoring NaN.
minnumf64Experimental
  Returns the minimum of two `f64` values, ignoring NaN.
minnumf128Experimental
  Returns the minimum of two `f128` values, ignoring NaN.
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)`.
offloadExperimental
  Generates the LLVM body of a wrapper function to offload a kernel `f`.
offset⚠Experimental
  Calculates the offset from a pointer.
offset_ofExperimental
  The offset of a field inside a type.
overflow_checksExperimental
  Returns whether we should perform some overflow-checking at runtime. This eventually evaluates to `cfg!(overflow_checks)`, but behaves different from `cfg!` when mixing crates built with different flags: if the crate has overflow checks enabled or carries the `#[rustc_inherit_overflow_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.
powf16Experimental
  Raises an `f16` to an `f16` power.
powf32Experimental
  Raises an `f32` to an `f32` power.
powf64Experimental
  Raises an `f64` to an `f64` power.
powf128Experimental
  Raises an `f128` to an `f128` power.
powif16Experimental
  Raises an `f16` to an integer power.
powif32Experimental
  Raises an `f32` to an integer power.
powif64Experimental
  Raises an `f64` to an integer power.
powif128Experimental
  Raises an `f128` to an integer power.
prefetch_read_dataExperimental
  The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction for the given address 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_instructionExperimental
  The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction for the given address 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_dataExperimental
  The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction for the given address 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_instructionExperimental
  The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction for the given address 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.
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.
roundf16Experimental
  Returns the nearest integer to an `f16`. Rounds half-way cases away from zero.
roundf32Experimental
  Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
roundf64Experimental
  Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
roundf128Experimental
  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).
sinf16Experimental
  Returns the sine of an `f16`.
sinf32Experimental
  Returns the sine of an `f32`.
sinf64Experimental
  Returns the sine of an `f64`.
sinf128Experimental
  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.
slice_get_unchecked⚠Experimental
  Projects to the `index`-th element of `slice_ptr`, as the same kind of pointer as the slice was provided – so `&mut [T] → &mut T`, `&[T] → &T`, `*mut [T] → *mut T`, or `*const [T] → *const T` – without a bounds check.
sqrtf16Experimental
  Returns the square root of an `f16`
sqrtf32Experimental
  Returns the square root of an `f32`
sqrtf64Experimental
  Returns the square root of an `f64`
sqrtf128Experimental
  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.
truncf16Experimental
  Returns the integer part of an `f16`.
truncf32Experimental
  Returns the integer part of an `f32`.
truncf64Experimental
  Returns the integer part of an `f64`.
truncf128Experimental
  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_id_eqExperimental
  Tests (at compile-time) if two `crate::any::TypeId` instances identify the same type. This is necessary because at const-eval time the actual discriminating data is opaque and cannot be inspected directly.
type_nameExperimental
  Gets a static string slice containing the name of a type.
type_ofExperimental
  Compute the type information of a concrete type. It can only be called at compile time, the backends do not implement it.
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_funnel_shl⚠Experimental
  Funnel Shift left.
unchecked_funnel_shr⚠Experimental
  Funnel Shift right.
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.
va_arg⚠Experimental
  Loads an argument of type `T` from the `va_list` `ap` and increment the argument `ap` points to.
va_copy⚠Experimental
  Copies the current location of arglist `src` to the arglist `dst`.
va_end⚠Experimental
  Destroy the arglist `ap` after initialization with `va_start` or `va_copy`.
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 `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 `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 `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_forExperimental
  The intrinsic returns the `U` vtable for `T` if `T` can be coerced to the trait object type `U`.
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.