//! 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/master/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/master/compiler/rustc_codegen_ssa/src/mir/intrinsic.rs>

//! and <https://github.com/rust-lang/rust/blob/master/compiler/rustc_codegen_llvm/src/intrinsic.rs>,

//! and for const evaluation 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 [`read_volatile`][ptr::read_volatile]

//! and [`write_volatile`][ptr::write_volatile].

//!

//! # Atomics

//!

//! The atomic intrinsics provide common atomic operations on machine

//! words, with multiple possible memory orderings. See the

//! [atomic types][atomic] 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.

#![unstable(

    feature = "core_intrinsics",

    reason = "intrinsics are unlikely to ever be stabilized, instead \

                      they should be used through stabilized interfaces \

                      in the rest of the standard library",

    issue = "none"

)]

#![allow(missing_docs)]

#[cfg(not(feature = "ferrocene_certified"))]

use crate::ffi::va_list::{VaArgSafe, VaListImpl};

#[cfg(not(feature = "ferrocene_certified"))]

use crate::marker::{ConstParamTy, DiscriminantKind, PointeeSized, Tuple};

#[cfg(feature = "ferrocene_certified")]

use crate::marker::{ConstParamTy, DiscriminantKind, Tuple};

use crate::ptr;

mod bounds;

#[cfg(not(feature = "ferrocene_certified"))]

pub mod fallback;

#[cfg(not(feature = "ferrocene_certified"))]

pub mod mir;

#[cfg(not(feature = "ferrocene_certified"))]

pub mod simd;

// These imports are used for simplifying intra-doc links

#[allow(unused_imports)]

#[cfg(all(target_has_atomic = "8", target_has_atomic = "32", target_has_atomic = "ptr"))]

#[cfg(not(feature = "ferrocene_certified"))]

use crate::sync::atomic::{self, AtomicBool, AtomicI32, AtomicIsize, AtomicU32, Ordering};

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

#[cfg_attr(not(feature = "ferrocene_certified"), derive(Debug, ConstParamTy, PartialEq, Eq))]

#[cfg_attr(feature = "ferrocene_certified", derive(ConstParamTy, PartialEq, Eq))]

pub enum AtomicOrdering {

    // These values must match the compiler's `AtomicOrdering` defined in

    // `rustc_middle/src/ty/consts/int.rs`!

    Relaxed = 0,

    Release = 1,

    Acquire = 2,

    AcqRel = 3,

    SeqCst = 4,

}

// N.B., these intrinsics take raw pointers because they mutate aliased

// memory, which is not valid for either `&` or `&mut`.

/// Stores a value if the current value is the same as the `old` value.

/// `T` must be an integer or pointer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `compare_exchange` method.

/// For example, [`AtomicBool::compare_exchange`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_cxchg<

    T: Copy,

    const ORD_SUCC: AtomicOrdering,

    const ORD_FAIL: AtomicOrdering,

>(

    dst: *mut T,

    old: T,

    src: T,

) -> (T, bool);

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

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `compare_exchange_weak` method.

/// For example, [`AtomicBool::compare_exchange_weak`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_cxchgweak<

    T: Copy,

    const ORD_SUCC: AtomicOrdering,

    const ORD_FAIL: AtomicOrdering,

>(

    _dst: *mut T,

    _old: T,

    _src: T,

) -> (T, bool);

/// Loads the current value of the pointer.

/// `T` must be an integer or pointer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `load` method. For example, [`AtomicBool::load`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_load<T: Copy, const ORD: AtomicOrdering>(src: *const T) -> T;

/// Stores the value at the specified memory location.

/// `T` must be an integer or pointer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `store` method. For example, [`AtomicBool::store`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_store<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, val: T);

/// Stores the value at the specified memory location, returning the old value.

/// `T` must be an integer or pointer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `swap` method. For example, [`AtomicBool::swap`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_xchg<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;

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

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `fetch_add` method. For example, [`AtomicIsize::fetch_add`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_xadd<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;

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

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `fetch_sub` method. For example, [`AtomicIsize::fetch_sub`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_xsub<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;

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

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `fetch_and` method. For example, [`AtomicBool::fetch_and`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_and<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;

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

///

/// The stabilized version of this intrinsic is available on the

/// [`AtomicBool`] type via the `fetch_nand` method. For example, [`AtomicBool::fetch_nand`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_nand<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;

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

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `fetch_or` method. For example, [`AtomicBool::fetch_or`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_or<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;

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

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] types via the `fetch_xor` method. For example, [`AtomicBool::fetch_xor`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_xor<T: Copy, U: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: U) -> T;

/// Maximum with the current value using a signed comparison.

/// `T` must be a signed integer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] signed integer types via the `fetch_max` method. For example, [`AtomicI32::fetch_max`].

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn atomic_max<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;

/// Minimum with the current value using a signed comparison.

/// `T` must be a signed integer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] signed integer types via the `fetch_min` method. For example, [`AtomicI32::fetch_min`].

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn atomic_min<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;

/// Minimum with the current value using an unsigned comparison.

/// `T` must be an unsigned integer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] unsigned integer types via the `fetch_min` method. For example, [`AtomicU32::fetch_min`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_umin<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;

/// Maximum with the current value using an unsigned comparison.

/// `T` must be an unsigned integer type.

///

/// The stabilized version of this intrinsic is available on the

/// [`atomic`] unsigned integer types via the `fetch_max` method. For example, [`AtomicU32::fetch_max`].

#[rustc_intrinsic]

#[rustc_nounwind]

pub unsafe fn atomic_umax<T: Copy, const ORD: AtomicOrdering>(dst: *mut T, src: T) -> T;

/// An atomic fence.

///

/// The stabilized version of this intrinsic is available in

/// [`atomic::fence`].

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn atomic_fence<const ORD: AtomicOrdering>();

/// An atomic fence for synchronization within a single thread.

///

/// The stabilized version of this intrinsic is available in

/// [`atomic::compiler_fence`].

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn atomic_singlethreadfence<const ORD: AtomicOrdering>();

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

///

/// The `LOCALITY` argument is a temporal locality specifier ranging from (0) - no locality,

/// to (3) - extremely local keep in cache.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[miri::intrinsic_fallback_is_spec]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn prefetch_read_data<T, const LOCALITY: i32>(data: *const T) {

    // This operation is a no-op, unless it is overridden by the backend.

    let _ = data;

}

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

///

/// The `LOCALITY` argument is a temporal locality specifier ranging from (0) - no locality,

/// to (3) - extremely local keep in cache.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[miri::intrinsic_fallback_is_spec]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn prefetch_write_data<T, const LOCALITY: i32>(data: *const T) {

    // This operation is a no-op, unless it is overridden by the backend.

    let _ = data;

}

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

///

/// The `LOCALITY` argument is a temporal locality specifier ranging from (0) - no locality,

/// to (3) - extremely local keep in cache.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[miri::intrinsic_fallback_is_spec]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn prefetch_read_instruction<T, const LOCALITY: i32>(data: *const T) {

    // This operation is a no-op, unless it is overridden by the backend.

    let _ = data;

}

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

///

/// The `LOCALITY` argument is a temporal locality specifier ranging from (0) - no locality,

/// to (3) - extremely local keep in cache.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[miri::intrinsic_fallback_is_spec]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn prefetch_write_instruction<T, const LOCALITY: i32>(data: *const T) {

    // This operation is a no-op, unless it is overridden by the backend.

    let _ = data;

}

/// Executes a breakpoint trap, for inspection by a debugger.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub fn breakpoint();

/// Magic intrinsic that derives its meaning from attributes

/// attached to the function.

///

/// For example, dataflow uses this to inject static assertions so

/// that `rustc_peek(potentially_uninitialized)` would actually

/// double-check that dataflow did indeed compute that it is

/// uninitialized at that point in the control flow.

///

/// This intrinsic should not be used outside of the compiler.

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub fn rustc_peek<T>(_: T) -> T;

/// Aborts the execution of the process.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

///

/// [`std::process::abort`](../../std/process/fn.abort.html) is to be preferred if possible,

/// as its behavior is more user-friendly and more stable.

///

/// The current implementation of `intrinsics::abort` is to invoke an invalid instruction,

/// on most platforms.

/// On Unix, the

/// process will probably terminate with a signal like `SIGABRT`, `SIGILL`, `SIGTRAP`, `SIGSEGV` or

/// `SIGBUS`.  The precise behavior is not guaranteed and not stable.

#[rustc_nounwind]

#[rustc_intrinsic]

pub fn abort() -> !;

/// Informs the optimizer that this point in the code is not reachable,

/// enabling further optimizations.

///

/// N.B., this is very different from the `unreachable!()` macro: Unlike the

/// macro, which panics when it is executed, it is *undefined behavior* to

/// reach code marked with this function.

///

/// The stabilized version of this intrinsic is [`core::hint::unreachable_unchecked`].

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

pub const unsafe fn unreachable() -> !;

/// Informs the optimizer that a condition is always true.

/// If the condition is false, the behavior is undefined.

///

/// No code is generated for this intrinsic, but the optimizer will try

/// to preserve it (and its condition) between passes, which may interfere

/// with optimization of surrounding code and reduce performance. It should

/// not be used if the invariant can be discovered by the optimizer on its

/// own, or if it does not enable any significant optimizations.

///

/// The stabilized version of this intrinsic is [`core::hint::assert_unchecked`].

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[unstable(feature = "core_intrinsics", issue = "none")]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const unsafe fn assume(b: bool) {

    if !b {

        // SAFETY: the caller must guarantee the argument is never `false`

        unsafe { unreachable() }

    }

}

/// Hints to the compiler that current code path is cold.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

///

/// This intrinsic does not have a stable counterpart.

#[unstable(feature = "core_intrinsics", issue = "none")]

#[rustc_intrinsic]

#[rustc_nounwind]

#[miri::intrinsic_fallback_is_spec]

#[cold]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn cold_path() {}

/// Hints to the compiler that branch condition is likely to be true.

/// Returns the value passed to it.

///

/// Any use other than with `if` statements will probably not have an effect.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

///

/// This intrinsic does not have a stable counterpart.

#[unstable(feature = "core_intrinsics", issue = "none")]

#[rustc_nounwind]

#[inline(always)]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn likely(b: bool) -> bool {

    if b {

        true

    } else {

        cold_path();

        false

    }

}

/// Hints to the compiler that branch condition is likely to be false.

/// Returns the value passed to it.

///

/// Any use other than with `if` statements will probably not have an effect.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

///

/// This intrinsic does not have a stable counterpart.

#[unstable(feature = "core_intrinsics", issue = "none")]

#[rustc_nounwind]

#[inline(always)]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn unlikely(b: bool) -> bool {

    if b {

        cold_path();

        true

    } else {

        false

    }

}

/// 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).

///

/// This is otherwise functionally equivalent to `if b { true_val } else { false_val }`.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

///

/// The public form of this intrinsic is [`core::hint::select_unpredictable`].

/// However unlike the public form, the intrinsic will not drop the value that

/// is not selected.

#[unstable(feature = "core_intrinsics", issue = "none")]

#[rustc_intrinsic]

#[rustc_nounwind]

#[miri::intrinsic_fallback_is_spec]

#[inline]

#[cfg(not(feature = "ferrocene_certified"))]

pub fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {

    if b { true_val } else { false_val }

}

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

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn assert_inhabited<T>();

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

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn assert_zero_valid<T>();

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

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn assert_mem_uninitialized_valid<T>();

/// Gets a reference to a static `Location` indicating where it was called.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

///

/// Consider using [`core::panic::Location::caller`] instead.

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn caller_location() -> &'static crate::panic::Location<'static>;

/// Moves a value out of scope without running drop glue.

///

/// This exists solely for [`crate::mem::forget_unsized`]; normal `forget` uses

/// `ManuallyDrop` instead.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn forget<T: ?Sized>(_: T);

/// Reinterprets the bits of a value of one type as another type.

///

/// Both types must have the same size. Compilation will fail if this is not guaranteed.

///

/// `transmute` is semantically equivalent to a bitwise move of one type

/// into another. It copies the bits from the source value into the

/// destination value, then forgets the original. Note that source and destination

/// are passed by-value, which means if `Src` or `Dst` contain padding, that padding

/// is *not* guaranteed to be preserved by `transmute`.

///

/// Both the argument and the result must be [valid](../../nomicon/what-unsafe-does.html) at

/// their given type. Violating this condition leads to [undefined behavior][ub]. The compiler

/// will generate code *assuming that you, the programmer, ensure that there will never be

/// undefined behavior*. It is therefore your responsibility to guarantee that every value

/// passed to `transmute` is valid at both types `Src` and `Dst`. Failing to uphold this condition

/// may lead to unexpected and unstable compilation results. This makes `transmute` **incredibly

/// unsafe**. `transmute` should be the absolute last resort.

///

/// Because `transmute` is a by-value operation, alignment of the *transmuted values

/// themselves* is not a concern. As with any other function, the compiler already ensures

/// both `Src` and `Dst` are properly aligned. However, when transmuting values that *point

/// elsewhere* (such as pointers, references, boxes…), the caller has to ensure proper

/// alignment of the pointed-to values.

///

/// The [nomicon](../../nomicon/transmutes.html) has additional documentation.

///

/// [ub]: ../../reference/behavior-considered-undefined.html

///

/// # Transmutation between pointers and integers

///

/// Special care has to be taken when transmuting between pointers and integers, e.g.

/// transmuting between `*const ()` and `usize`.

///

/// Transmuting *pointers to integers* in a `const` context is [undefined behavior][ub], unless

/// the pointer was originally created *from* an integer. (That includes this function

/// specifically, integer-to-pointer casts, and helpers like [`dangling`][crate::ptr::dangling],

/// but also semantically-equivalent conversions such as punning through `repr(C)` union

/// fields.) Any attempt to use the resulting value for integer operations will abort

/// const-evaluation. (And even outside `const`, such transmutation is touching on many

/// unspecified aspects of the Rust memory model and should be avoided. See below for

/// alternatives.)

///

/// Transmuting *integers to pointers* is a largely unspecified operation. It is likely *not*

/// equivalent to an `as` cast. Doing non-zero-sized memory accesses with a pointer constructed

/// this way is currently considered undefined behavior.

///

/// All this also applies when the integer is nested inside an array, tuple, struct, or enum.

/// However, `MaybeUninit<usize>` is not considered an integer type for the purpose of this

/// section. Transmuting `*const ()` to `MaybeUninit<usize>` is fine---but then calling

/// `assume_init()` on that result is considered as completing the pointer-to-integer transmute

/// and thus runs into the issues discussed above.

///

/// In particular, doing a pointer-to-integer-to-pointer roundtrip via `transmute` is *not* a

/// lossless process. If you want to round-trip a pointer through an integer in a way that you

/// can get back the original pointer, you need to use `as` casts, or replace the integer type

/// by `MaybeUninit<$int>` (and never call `assume_init()`). If you are looking for a way to

/// store data of arbitrary type, also use `MaybeUninit<T>` (that will also handle uninitialized

/// memory due to padding). If you specifically need to store something that is "either an

/// integer or a pointer", use `*mut ()`: integers can be converted to pointers and back without

/// any loss (via `as` casts or via `transmute`).

///

/// # Examples

///

/// There are a few things that `transmute` is really useful for.

///

/// Turning a pointer into a function pointer. This is *not* portable to

/// machines where function pointers and data pointers have different sizes.

///

/// ```

/// fn foo() -> i32 {

///     0

/// }

/// // Crucially, we `as`-cast to a raw pointer before `transmute`ing to a function pointer.

/// // This avoids an integer-to-pointer `transmute`, which can be problematic.

/// // Transmuting between raw pointers and function pointers (i.e., two pointer types) is fine.

/// let pointer = foo as *const ();

/// let function = unsafe {

///     std::mem::transmute::<*const (), fn() -> i32>(pointer)

/// };

/// assert_eq!(function(), 0);

/// ```

///

/// Extending a lifetime, or shortening an invariant lifetime. This is

/// advanced, very unsafe Rust!

///

/// ```

/// struct R<'a>(&'a i32);

/// unsafe fn extend_lifetime<'b>(r: R<'b>) -> R<'static> {

///     unsafe { std::mem::transmute::<R<'b>, R<'static>>(r) }

/// }

///

/// unsafe fn shorten_invariant_lifetime<'b, 'c>(r: &'b mut R<'static>)

///                                              -> &'b mut R<'c> {

///     unsafe { std::mem::transmute::<&'b mut R<'static>, &'b mut R<'c>>(r) }

/// }

/// ```

///

/// # Alternatives

///

/// Don't despair: many uses of `transmute` can be achieved through other means.

/// Below are common applications of `transmute` which can be replaced with safer

/// constructs.

///

/// Turning raw bytes (`[u8; SZ]`) into `u32`, `f64`, etc.:

///

/// ```

/// # #![allow(unnecessary_transmutes)]

/// let raw_bytes = [0x78, 0x56, 0x34, 0x12];

///

/// let num = unsafe {

///     std::mem::transmute::<[u8; 4], u32>(raw_bytes)

/// };

///

/// // use `u32::from_ne_bytes` instead

/// let num = u32::from_ne_bytes(raw_bytes);

/// // or use `u32::from_le_bytes` or `u32::from_be_bytes` to specify the endianness

/// let num = u32::from_le_bytes(raw_bytes);

/// assert_eq!(num, 0x12345678);

/// let num = u32::from_be_bytes(raw_bytes);

/// assert_eq!(num, 0x78563412);

/// ```

///

/// Turning a pointer into a `usize`:

///

/// ```no_run

/// let ptr = &0;

/// let ptr_num_transmute = unsafe {

///     std::mem::transmute::<&i32, usize>(ptr)

/// };

///

/// // Use an `as` cast instead

/// let ptr_num_cast = ptr as *const i32 as usize;

/// ```

///

/// Note that using `transmute` to turn a pointer to a `usize` is (as noted above) [undefined

/// behavior][ub] in `const` contexts. Also outside of consts, this operation might not behave

/// as expected -- this is touching on many unspecified aspects of the Rust memory model.

/// Depending on what the code is doing, the following alternatives are preferable to

/// pointer-to-integer transmutation:

/// - If the code just wants to store data of arbitrary type in some buffer and needs to pick a

///   type for that buffer, it can use [`MaybeUninit`][crate::mem::MaybeUninit].

/// - If the code actually wants to work on the address the pointer points to, it can use `as`

///   casts or [`ptr.addr()`][pointer::addr].

///

/// Turning a `*mut T` into a `&mut T`:

///

/// ```

/// let ptr: *mut i32 = &mut 0;

/// let ref_transmuted = unsafe {

///     std::mem::transmute::<*mut i32, &mut i32>(ptr)

/// };

///

/// // Use a reborrow instead

/// let ref_casted = unsafe { &mut *ptr };

/// ```

///

/// Turning a `&mut T` into a `&mut U`:

///

/// ```

/// let ptr = &mut 0;

/// let val_transmuted = unsafe {

///     std::mem::transmute::<&mut i32, &mut u32>(ptr)

/// };

///

/// // Now, put together `as` and reborrowing - note the chaining of `as`

/// // `as` is not transitive

/// let val_casts = unsafe { &mut *(ptr as *mut i32 as *mut u32) };

/// ```

///

/// Turning a `&str` into a `&[u8]`:

///

/// ```

/// // this is not a good way to do this.

/// let slice = unsafe { std::mem::transmute::<&str, &[u8]>("Rust") };

/// assert_eq!(slice, &[82, 117, 115, 116]);

///

/// // You could use `str::as_bytes`

/// let slice = "Rust".as_bytes();

/// assert_eq!(slice, &[82, 117, 115, 116]);

///

/// // Or, just use a byte string, if you have control over the string

/// // literal

/// assert_eq!(b"Rust", &[82, 117, 115, 116]);

/// ```

///

/// Turning a `Vec<&T>` into a `Vec<Option<&T>>`.

///

/// To transmute the inner type of the contents of a container, you must make sure to not

/// violate any of the container's invariants. For `Vec`, this means that both the size

/// *and alignment* of the inner types have to match. Other containers might rely on the

/// size of the type, alignment, or even the `TypeId`, in which case transmuting wouldn't

/// be possible at all without violating the container invariants.

///

/// ```

/// let store = [0, 1, 2, 3];

/// let v_orig = store.iter().collect::<Vec<&i32>>();

///

/// // clone the vector as we will reuse them later

/// let v_clone = v_orig.clone();

///

/// // Using transmute: this relies on the unspecified data layout of `Vec`, which is a

/// // bad idea and could cause Undefined Behavior.

/// // However, it is no-copy.

/// let v_transmuted = unsafe {

///     std::mem::transmute::<Vec<&i32>, Vec<Option<&i32>>>(v_clone)

/// };

///

/// let v_clone = v_orig.clone();

///

/// // This is the suggested, safe way.

/// // It may copy the entire vector into a new one though, but also may not.

/// let v_collected = v_clone.into_iter()

///                          .map(Some)

///                          .collect::<Vec<Option<&i32>>>();

///

/// let v_clone = v_orig.clone();

///

/// // This is the proper no-copy, unsafe way of "transmuting" a `Vec`, without relying on the

/// // data layout. Instead of literally calling `transmute`, we perform a pointer cast, but

/// // in terms of converting the original inner type (`&i32`) to the new one (`Option<&i32>`),

/// // this has all the same caveats. Besides the information provided above, also consult the

/// // [`from_raw_parts`] documentation.

/// let v_from_raw = unsafe {

// FIXME Update this when vec_into_raw_parts is stabilized

///     // Ensure the original vector is not dropped.

///     let mut v_clone = std::mem::ManuallyDrop::new(v_clone);

///     Vec::from_raw_parts(v_clone.as_mut_ptr() as *mut Option<&i32>,

///                         v_clone.len(),

///                         v_clone.capacity())

/// };

/// ```

///

/// [`from_raw_parts`]: ../../std/vec/struct.Vec.html#method.from_raw_parts

///

/// Implementing `split_at_mut`:

///

/// ```

/// use std::{slice, mem};

///

/// // There are multiple ways to do this, and there are multiple problems

/// // with the following (transmute) way.

/// fn split_at_mut_transmute<T>(slice: &mut [T], mid: usize)

///                              -> (&mut [T], &mut [T]) {

///     let len = slice.len();

///     assert!(mid <= len);

///     unsafe {

///         let slice2 = mem::transmute::<&mut [T], &mut [T]>(slice);

///         // first: transmute is not type safe; all it checks is that T and

///         // U are of the same size. Second, right here, you have two

///         // mutable references pointing to the same memory.

///         (&mut slice[0..mid], &mut slice2[mid..len])

///     }

/// }

///

/// // This gets rid of the type safety problems; `&mut *` will *only* give

/// // you a `&mut T` from a `&mut T` or `*mut T`.

/// fn split_at_mut_casts<T>(slice: &mut [T], mid: usize)

///                          -> (&mut [T], &mut [T]) {

///     let len = slice.len();

///     assert!(mid <= len);

///     unsafe {

///         let slice2 = &mut *(slice as *mut [T]);

///         // however, you still have two mutable references pointing to

///         // the same memory.

///         (&mut slice[0..mid], &mut slice2[mid..len])

///     }

/// }

///

/// // This is how the standard library does it. This is the best method, if

/// // you need to do something like this

/// fn split_at_stdlib<T>(slice: &mut [T], mid: usize)

///                       -> (&mut [T], &mut [T]) {

///     let len = slice.len();

///     assert!(mid <= len);

///     unsafe {

///         let ptr = slice.as_mut_ptr();

///         // This now has three mutable references pointing at the same

///         // memory. `slice`, the rvalue ret.0, and the rvalue ret.1.

///         // `slice` is never used after `let ptr = ...`, and so one can

///         // treat it as "dead", and therefore, you only have two real

///         // mutable slices.

///         (slice::from_raw_parts_mut(ptr, mid),

///          slice::from_raw_parts_mut(ptr.add(mid), len - mid))

///     }

/// }

/// ```

#[stable(feature = "rust1", since = "1.0.0")]

#[rustc_allowed_through_unstable_modules = "import this function via `std::mem` instead"]

#[rustc_const_stable(feature = "const_transmute", since = "1.56.0")]

#[rustc_diagnostic_item = "transmute"]

#[rustc_nounwind]

#[rustc_intrinsic]

pub const unsafe fn transmute<Src, Dst>(src: Src) -> Dst;

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

///

/// Prefer normal `transmute` where possible, for the extra checking, since

/// both do exactly the same thing at runtime, if they both compile.

///

/// This is not expected to ever be exposed directly to users, rather it

/// may eventually be exposed through some more-constrained API.

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const unsafe fn transmute_unchecked<Src, Dst>(src: Src) -> Dst;

/// Returns `true` if the actual type given as `T` requires drop

/// glue; returns `false` if the actual type provided for `T`

/// implements `Copy`.

///

/// If the actual type neither requires drop glue nor implements

/// `Copy`, then the return value of this function is unspecified.

///

/// Note that, unlike most intrinsics, this can only be called at compile-time

/// as backends do not have an implementation for it. The only caller (its

/// stable counterpart) wraps this intrinsic call in a `const` block so that

/// backends only see an evaluated constant.

///

/// The stabilized version of this intrinsic is [`mem::needs_drop`](crate::mem::needs_drop).

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const fn needs_drop<T: ?Sized>() -> bool;

/// Calculates the offset from a pointer.

///

/// This is implemented as an intrinsic to avoid converting to and from an

/// integer, since the conversion would throw away aliasing information.

///

/// This can only be used with `Ptr` as a raw pointer type (`*mut` or `*const`)

/// to a `Sized` pointee and with `Delta` as `usize` or `isize`.  Any other

/// instantiations may arbitrarily misbehave, and that's *not* a compiler bug.

///

/// # Safety

///

/// If the computed offset is non-zero, then both the starting and resulting pointer must be

/// either in bounds or at the end of an allocation. If either pointer is out

/// of bounds or arithmetic overflow occurs then this operation is undefined behavior.

///

/// The stabilized version of this intrinsic is [`pointer::offset`].

#[must_use = "returns a new pointer rather than modifying its argument"]

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const unsafe fn offset<Ptr: bounds::BuiltinDeref, Delta>(dst: Ptr, offset: Delta) -> Ptr;

/// Calculates the offset from a pointer, potentially wrapping.

///

/// This is implemented as an intrinsic to avoid converting to and from an

/// integer, since the conversion inhibits certain optimizations.

///

/// # Safety

///

/// Unlike the `offset` intrinsic, this intrinsic does not restrict the

/// resulting pointer to point into or at the end of an allocated

/// object, and it wraps with two's complement arithmetic. The resulting

/// value is not necessarily valid to be used to actually access memory.

///

/// The stabilized version of this intrinsic is [`pointer::wrapping_offset`].

#[must_use = "returns a new pointer rather than modifying its argument"]

#[rustc_intrinsic_const_stable_indirect]

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const unsafe fn arith_offset<T>(dst: *const T, offset: isize) -> *const T;

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

///

/// This is exposed via `<usize as SliceIndex>::get(_unchecked)(_mut)`,

/// and isn't intended to be used elsewhere.

///

/// Expands in MIR to `{&, &mut, &raw const, &raw mut} (*slice_ptr)[index]`,

/// depending on the types involved, so no backend support is needed.

///

/// # Safety

///

/// - `index < PtrMetadata(slice_ptr)`, so the indexing is in-bounds for the slice

/// - the resulting offsetting is in-bounds of the allocation, which is

///   always the case for references, but needs to be upheld manually for pointers

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub const unsafe fn slice_get_unchecked<

    ItemPtr: bounds::ChangePointee<[T], Pointee = T, Output = SlicePtr>,

    SlicePtr,

    T,

>(

    slice_ptr: SlicePtr,

    index: usize,

) -> ItemPtr;

/// Masks out bits of the pointer according to a mask.

///

/// Note that, unlike most intrinsics, this is safe to call;

/// it does not require an `unsafe` block.

/// Therefore, implementations must not require the user to uphold

/// any safety invariants.

///

/// Consider using [`pointer::mask`] instead.

#[rustc_nounwind]

#[rustc_intrinsic]

#[cfg(not(feature = "ferrocene_certified"))]

pub fn ptr_mask<T>(ptr: *const T, mask: usize) -> *const T;

/// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with

/// a size of `count` * `size_of::<T>()` and an alignment of `align_of::<T>()`.

///

/// This intrinsic does not have a stable counterpart.

/// # Safety

///

/// The safety requirements are consistent with [`copy_nonoverlapping`]

/// while the read and write behaviors are volatile,

/// which means it will not be optimized out unless `_count` or `size_of::<T>()` is equal to zero.

///

/// [`copy_nonoverlapping`]: ptr::copy_nonoverlapping

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn volatile_copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: usize);

/// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with

/// a size of `count * size_of::<T>()` and an alignment of `align_of::<T>()`.

///

/// The volatile parameter is set to `true`, so it will not be optimized out

/// unless size is equal to zero.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn volatile_copy_memory<T>(dst: *mut T, src: *const T, count: usize);

/// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a

/// size of `count * size_of::<T>()` and an alignment of `align_of::<T>()`.

///

/// This intrinsic does not have a stable counterpart.

/// # Safety

///

/// The safety requirements are consistent with [`write_bytes`] while the write behavior is volatile,

/// which means it will not be optimized out unless `_count` or `size_of::<T>()` is equal to zero.

///

/// [`write_bytes`]: ptr::write_bytes

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn volatile_set_memory<T>(dst: *mut T, val: u8, count: usize);

/// Performs a volatile load from the `src` pointer.

///

/// The stabilized version of this intrinsic is [`core::ptr::read_volatile`].

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn volatile_load<T>(src: *const T) -> T;

/// Performs a volatile store to the `dst` pointer.

///

/// The stabilized version of this intrinsic is [`core::ptr::write_volatile`].

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn volatile_store<T>(dst: *mut T, val: T);

/// Performs a volatile load from the `src` pointer

/// The pointer is not required to be aligned.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[rustc_diagnostic_item = "intrinsics_unaligned_volatile_load"]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn unaligned_volatile_load<T>(src: *const T) -> T;

/// Performs a volatile store to the `dst` pointer.

/// The pointer is not required to be aligned.

///

/// This intrinsic does not have a stable counterpart.

#[rustc_intrinsic]

#[rustc_nounwind]

#[rustc_diagnostic_item = "intrinsics_unaligned_volatile_store"]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn unaligned_volatile_store<T>(dst: *mut T, val: T);

/// Returns the square root of an `f16`

///

/// The stabilized version of this intrinsic is

/// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sqrtf16(x: f16) -> f16;

/// Returns the square root of an `f32`

///

/// The stabilized version of this intrinsic is

/// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sqrtf32(x: f32) -> f32;

/// Returns the square root of an `f64`

///

/// The stabilized version of this intrinsic is

/// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sqrtf64(x: f64) -> f64;

/// Returns the square root of an `f128`

///

/// The stabilized version of this intrinsic is

/// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sqrtf128(x: f128) -> f128;

/// Raises an `f16` to an integer power.

///

/// The stabilized version of this intrinsic is

/// [`f16::powi`](../../std/primitive.f16.html#method.powi)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powif16(a: f16, x: i32) -> f16;

/// Raises an `f32` to an integer power.

///

/// The stabilized version of this intrinsic is

/// [`f32::powi`](../../std/primitive.f32.html#method.powi)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powif32(a: f32, x: i32) -> f32;

/// Raises an `f64` to an integer power.

///

/// The stabilized version of this intrinsic is

/// [`f64::powi`](../../std/primitive.f64.html#method.powi)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powif64(a: f64, x: i32) -> f64;

/// Raises an `f128` to an integer power.

///

/// The stabilized version of this intrinsic is

/// [`f128::powi`](../../std/primitive.f128.html#method.powi)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powif128(a: f128, x: i32) -> f128;

/// Returns the sine of an `f16`.

///

/// The stabilized version of this intrinsic is

/// [`f16::sin`](../../std/primitive.f16.html#method.sin)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sinf16(x: f16) -> f16;

/// Returns the sine of an `f32`.

///

/// The stabilized version of this intrinsic is

/// [`f32::sin`](../../std/primitive.f32.html#method.sin)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sinf32(x: f32) -> f32;

/// Returns the sine of an `f64`.

///

/// The stabilized version of this intrinsic is

/// [`f64::sin`](../../std/primitive.f64.html#method.sin)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sinf64(x: f64) -> f64;

/// Returns the sine of an `f128`.

///

/// The stabilized version of this intrinsic is

/// [`f128::sin`](../../std/primitive.f128.html#method.sin)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn sinf128(x: f128) -> f128;

/// Returns the cosine of an `f16`.

///

/// The stabilized version of this intrinsic is

/// [`f16::cos`](../../std/primitive.f16.html#method.cos)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn cosf16(x: f16) -> f16;

/// Returns the cosine of an `f32`.

///

/// The stabilized version of this intrinsic is

/// [`f32::cos`](../../std/primitive.f32.html#method.cos)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn cosf32(x: f32) -> f32;

/// Returns the cosine of an `f64`.

///

/// The stabilized version of this intrinsic is

/// [`f64::cos`](../../std/primitive.f64.html#method.cos)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn cosf64(x: f64) -> f64;

/// Returns the cosine of an `f128`.

///

/// The stabilized version of this intrinsic is

/// [`f128::cos`](../../std/primitive.f128.html#method.cos)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn cosf128(x: f128) -> f128;

/// Raises an `f16` to an `f16` power.

///

/// The stabilized version of this intrinsic is

/// [`f16::powf`](../../std/primitive.f16.html#method.powf)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powf16(a: f16, x: f16) -> f16;

/// Raises an `f32` to an `f32` power.

///

/// The stabilized version of this intrinsic is

/// [`f32::powf`](../../std/primitive.f32.html#method.powf)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powf32(a: f32, x: f32) -> f32;

/// Raises an `f64` to an `f64` power.

///

/// The stabilized version of this intrinsic is

/// [`f64::powf`](../../std/primitive.f64.html#method.powf)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powf64(a: f64, x: f64) -> f64;

/// Raises an `f128` to an `f128` power.

///

/// The stabilized version of this intrinsic is

/// [`f128::powf`](../../std/primitive.f128.html#method.powf)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn powf128(a: f128, x: f128) -> f128;

/// Returns the exponential of an `f16`.

///

/// The stabilized version of this intrinsic is

/// [`f16::exp`](../../std/primitive.f16.html#method.exp)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn expf16(x: f16) -> f16;

/// Returns the exponential of an `f32`.

///

/// The stabilized version of this intrinsic is

/// [`f32::exp`](../../std/primitive.f32.html#method.exp)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn expf32(x: f32) -> f32;

/// Returns the exponential of an `f64`.

///

/// The stabilized version of this intrinsic is

/// [`f64::exp`](../../std/primitive.f64.html#method.exp)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn expf64(x: f64) -> f64;

/// Returns the exponential of an `f128`.

///

/// The stabilized version of this intrinsic is

/// [`f128::exp`](../../std/primitive.f128.html#method.exp)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn expf128(x: f128) -> f128;

/// Returns 2 raised to the power of an `f16`.

///

/// The stabilized version of this intrinsic is

/// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn exp2f16(x: f16) -> f16;

/// Returns 2 raised to the power of an `f32`.

///

/// The stabilized version of this intrinsic is

/// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn exp2f32(x: f32) -> f32;

/// Returns 2 raised to the power of an `f64`.

///

/// The stabilized version of this intrinsic is

/// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn exp2f64(x: f64) -> f64;

/// Returns 2 raised to the power of an `f128`.

///

/// The stabilized version of this intrinsic is

/// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn exp2f128(x: f128) -> f128;

/// Returns the natural logarithm of an `f16`.

///

/// The stabilized version of this intrinsic is

/// [`f16::ln`](../../std/primitive.f16.html#method.ln)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn logf16(x: f16) -> f16;

/// Returns the natural logarithm of an `f32`.

///

/// The stabilized version of this intrinsic is

/// [`f32::ln`](../../std/primitive.f32.html#method.ln)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn logf32(x: f32) -> f32;

/// Returns the natural logarithm of an `f64`.

///

/// The stabilized version of this intrinsic is

/// [`f64::ln`](../../std/primitive.f64.html#method.ln)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn logf64(x: f64) -> f64;

/// Returns the natural logarithm of an `f128`.

///

/// The stabilized version of this intrinsic is

/// [`f128::ln`](../../std/primitive.f128.html#method.ln)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn logf128(x: f128) -> f128;

/// Returns the base 10 logarithm of an `f16`.

///

/// The stabilized version of this intrinsic is

/// [`f16::log10`](../../std/primitive.f16.html#method.log10)

#[rustc_intrinsic]

#[rustc_nounwind]

#[cfg(not(feature = "ferrocene_certified"))]

pub unsafe fn log10f16(x: f16) -> f16;