W3cubDocs

/Rust

Module intrinsics

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

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
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.
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_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.

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/intrinsics/index.html