Module intrinsics

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

Compiler intrinsics.

The corresponding definitions are in https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/intrinsic.rs. The corresponding const implementations are in https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/intrinsics.rs.

Const intrinsics

Note: any changes to the constness of intrinsics should be discussed with the language team. This includes changes in the stability of the constness.

In order to make an intrinsic usable at compile-time, one needs to copy the implementation from https://github.com/rust-lang/miri/blob/master/src/shims/intrinsics to https://github.com/rust-lang/rust/blob/master/compiler/rustc_const_eval/src/interpret/intrinsics.rs and add a #[rustc_const_unstable(feature = "const_such_and_such", issue = "01234")] to the intrinsic declaration.

If an intrinsic is supposed to be used from a const fn with a rustc_const_stable attribute, #[rustc_const_stable_indirect] needs to be added to the intrinsic (#[rustc_const_unstable] can be removed then). Such a change should not be done without T-lang consultation, 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

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

Traits

• AggregateRawPtrExperimental

Functions

• copy^⚠
  Copies count * size_of::<T>() bytes from src to dst. The source and destination may overlap.
• copy_nonoverlapping^⚠
  Copies count * size_of::<T>() bytes from src to dst. The source and destination must not overlap.
• drop_in_place^⚠Deprecated
• transmute^⚠
  Reinterprets the bits of a value of one type as another type.
• write_bytes^⚠
  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.
• atomic_and_acquire^⚠Experimental
  Bitwise and with the current value, returning the previous value.
• atomic_and_relaxed^⚠Experimental
  Bitwise and with the current value, returning the previous value.
• atomic_and_release^⚠Experimental
  Bitwise and with the current value, returning the previous value.
• atomic_and_seqcst^⚠Experimental
  Bitwise and with the current value, returning the previous value.
• atomic_cxchg_acqrel_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_acqrel_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_acqrel_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_acquire_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_acquire_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_acquire_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_relaxed_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_relaxed_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_relaxed_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_release_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_release_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_release_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_seqcst_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_seqcst_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchg_seqcst_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_acqrel_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_acqrel_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_acqrel_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_acquire_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_acquire_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_acquire_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_relaxed_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_relaxed_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_relaxed_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_release_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_release_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_release_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_seqcst_acquire^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_seqcst_relaxed^⚠Experimental
  Stores a value if the current value is the same as the old value.
• atomic_cxchgweak_seqcst_seqcst^⚠Experimental
  Stores a value if the current value is the same as the old value.
• 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.
• atomic_load_relaxed^⚠Experimental
  Loads the current value of the pointer.
• atomic_load_seqcst^⚠Experimental
  Loads the current value of the pointer.
• 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.
• atomic_max_acquire^⚠Experimental
  Maximum with the current value using a signed comparison.
• atomic_max_relaxed^⚠Experimental
  Maximum with the current value.
• atomic_max_release^⚠Experimental
  Maximum with the current value using a signed comparison.
• atomic_max_seqcst^⚠Experimental
  Maximum with the current value using a signed comparison.
• atomic_min_acqrel^⚠Experimental
  Minimum with the current value using a signed comparison.
• atomic_min_acquire^⚠Experimental
  Minimum with the current value using a signed comparison.
• atomic_min_relaxed^⚠Experimental
  Minimum with the current value using a signed comparison.
• atomic_min_release^⚠Experimental
  Minimum with the current value using a signed comparison.
• atomic_min_seqcst^⚠Experimental
  Minimum with the current value using a signed comparison.
• atomic_nand_acqrel^⚠Experimental
  Bitwise nand with the current value, returning the previous value.
• atomic_nand_acquire^⚠Experimental
  Bitwise nand with the current value, returning the previous value.
• atomic_nand_relaxed^⚠Experimental
  Bitwise nand with the current value, returning the previous value.
• atomic_nand_release^⚠Experimental
  Bitwise nand with the current value, returning the previous value.
• atomic_nand_seqcst^⚠Experimental
  Bitwise nand with the current value, returning the previous value.
• atomic_or_acqrel^⚠Experimental
  Bitwise or with the current value, returning the previous value.
• atomic_or_acquire^⚠Experimental
  Bitwise or with the current value, returning the previous value.
• atomic_or_relaxed^⚠Experimental
  Bitwise or with the current value, returning the previous value.
• atomic_or_release^⚠Experimental
  Bitwise or with the current value, returning the previous value.
• atomic_or_seqcst^⚠Experimental
  Bitwise or with the current value, returning the previous value.
• 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.
• atomic_store_release^⚠Experimental
  Stores the value at the specified memory location.
• atomic_store_seqcst^⚠Experimental
  Stores the value at the specified memory location.
• 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.
• atomic_umax_acquire^⚠Experimental
  Maximum with the current value using an unsigned comparison.
• atomic_umax_relaxed^⚠Experimental
  Maximum with the current value using an unsigned comparison.
• atomic_umax_release^⚠Experimental
  Maximum with the current value using an unsigned comparison.
• atomic_umax_seqcst^⚠Experimental
  Maximum with the current value using an unsigned comparison.
• atomic_umin_acqrel^⚠Experimental
  Minimum with the current value using an unsigned comparison.
• atomic_umin_acquire^⚠Experimental
  Minimum with the current value using an unsigned comparison.
• atomic_umin_relaxed^⚠Experimental
  Minimum with the current value using an unsigned comparison.
• atomic_umin_release^⚠Experimental
  Minimum with the current value using an unsigned comparison.
• atomic_umin_seqcst^⚠Experimental
  Minimum with the current value using an unsigned comparison.
• atomic_xadd_acqrel^⚠Experimental
  Adds to the current value, returning the previous value.
• atomic_xadd_acquire^⚠Experimental
  Adds to the current value, returning the previous value.
• atomic_xadd_relaxed^⚠Experimental
  Adds to the current value, returning the previous value.
• atomic_xadd_release^⚠Experimental
  Adds to the current value, returning the previous value.
• atomic_xadd_seqcst^⚠Experimental
  Adds to the current value, returning the previous value.
• atomic_xchg_acqrel^⚠Experimental
  Stores the value at the specified memory location, returning the old value.
• atomic_xchg_acquire^⚠Experimental
  Stores the value at the specified memory location, returning the old value.
• atomic_xchg_relaxed^⚠Experimental
  Stores the value at the specified memory location, returning the old value.
• atomic_xchg_release^⚠Experimental
  Stores the value at the specified memory location, returning the old value.
• atomic_xchg_seqcst^⚠Experimental
  Stores the value at the specified memory location, returning the old value.
• atomic_xor_acqrel^⚠Experimental
  Bitwise xor with the current value, returning the previous value.
• atomic_xor_acquire^⚠Experimental
  Bitwise xor with the current value, returning the previous value.
• atomic_xor_relaxed^⚠Experimental
  Bitwise xor with the current value, returning the previous value.
• atomic_xor_release^⚠Experimental
  Bitwise xor with the current value, returning the previous value.
• atomic_xor_seqcst^⚠Experimental
  Bitwise xor with the current value, returning the previous value.
• atomic_xsub_acqrel^⚠Experimental
  Subtract from the current value, returning the previous value.
• atomic_xsub_acquire^⚠Experimental
  Subtract from the current value, returning the previous value.
• atomic_xsub_relaxed^⚠Experimental
  Subtract from the current value, returning the previous value.
• atomic_xsub_release^⚠Experimental
  Subtract from the current value, returning the previous value.
• atomic_xsub_seqcst^⚠Experimental
  Subtract from the current value, returning the previous value.
• bitreverseExperimental
  Reverses the bits in an integer type T.
• black_boxExperimental
  See documentation of std::hint::black_box for details.
• breakpoint^⚠Experimental
  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.
• 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.
• 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.
• 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.
• 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.
• 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
• nearbyintf16^⚠Experimental
  Returns the nearest integer to an f16. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• nearbyintf32^⚠Experimental
  Returns the nearest integer to an f32. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• nearbyintf64^⚠Experimental
  Returns the nearest integer to an f64. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• nearbyintf128^⚠Experimental
  Returns the nearest integer to an f128. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• 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>::sub_ptr 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.
• rintf16^⚠Experimental
  Returns the nearest integer to an f16. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• rintf32^⚠Experimental
  Returns the nearest integer to an f32. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• rintf64^⚠Experimental
  Returns the nearest integer to an f64. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• rintf128^⚠Experimental
  Returns the nearest integer to an f128. Changing the rounding mode is not possible in Rust, so this rounds half-way cases to the number with an even least significant digit.
• rotate_leftExperimental
  Performs rotate left.
• rotate_rightExperimental
  Performs rotate right.
• roundevenf16^⚠Experimental
  Returns the nearest integer to an f16. Rounds half-way cases to the number with an even least significant digit.
• roundevenf32^⚠Experimental
  Returns the nearest integer to an f32. Rounds half-way cases to the number with an even least significant digit.
• roundevenf64^⚠Experimental
  Returns the nearest integer to an f64. Rounds half-way cases to the number with an even least significant digit.
• roundevenf128^⚠Experimental
  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 integer arguments.
• 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^⚠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 2^N, where N is the width of T in bits.
• wrapping_mulExperimental
  Returns (a * b) mod 2^N, where N is the width of T in bits.
• wrapping_subExperimental
  Returns (a - b) mod 2^N, 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.