//! guaranteed to happen in order. This is the standard mode for working
//! with atomic types and is equivalent to Java's `volatile`.
-#![unstable(feature = "core_intrinsics",
- reason = "intrinsics are unlikely to ever be stabilized, instead \
+#![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 = "0")]
+ issue = "none"
+)]
#![allow(missing_docs)]
use crate::mem;
#[stable(feature = "drop_in_place", since = "1.8.0")]
-#[rustc_deprecated(reason = "no longer an intrinsic - use `ptr::drop_in_place` directly",
- since = "1.18.0")]
+#[rustc_deprecated(
+ reason = "no longer an intrinsic - use `ptr::drop_in_place` directly",
+ since = "1.18.0"
+)]
pub use crate::ptr::drop_in_place;
extern "rust-intrinsic" {
#[rustc_const_stable(feature = "const_min_align_of", since = "1.40.0")]
pub fn min_align_of<T>() -> usize;
- #[rustc_const_unstable(feature = "const_pref_align_of", issue = "0")]
+ #[rustc_const_unstable(feature = "const_pref_align_of", issue = "none")]
pub fn pref_align_of<T>() -> usize;
/// The size of the referenced value in bytes.
pub fn min_align_of_val<T: ?Sized>(_: &T) -> usize;
/// Gets a static string slice containing the name of a type.
- #[rustc_const_unstable(feature = "const_type_name", issue = "0")]
+ #[rustc_const_unstable(feature = "const_type_name", issue = "none")]
pub fn type_name<T: ?Sized>() -> &'static str;
/// 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.
- #[rustc_const_unstable(feature = "const_type_id", issue = "0")]
+ #[rustc_const_unstable(feature = "const_type_id", issue = "none")]
pub fn type_id<T: ?Sized + 'static>() -> u64;
/// A guard for unsafe functions that cannot ever be executed if `T` is uninhabited:
/// which is unsafe unless `T` is `Copy`. Also, even if T is
/// `Copy`, an all-zero value may not correspond to any legitimate
/// state for the type in question.
- #[unstable(feature = "core_intrinsics",
- reason = "intrinsics are unlikely to ever be stabilized, instead \
+ #[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 = "0")]
- #[rustc_deprecated(reason = "superseded by MaybeUninit, removal planned",
- since = "1.38.0")]
+ issue = "none"
+ )]
+ #[rustc_deprecated(reason = "superseded by MaybeUninit, removal planned", since = "1.38.0")]
pub fn init<T>() -> T;
/// Creates an uninitialized value.
/// state, which means it may claim either dropped or
/// undropped. In the general case one must use `ptr::write` to
/// initialize memory previous set to the result of `uninit`.
- #[unstable(feature = "core_intrinsics",
- reason = "intrinsics are unlikely to ever be stabilized, instead \
+ #[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 = "0")]
- #[rustc_deprecated(reason = "superseded by MaybeUninit, removal planned",
- since = "1.38.0")]
+ issue = "none"
+ )]
+ #[rustc_deprecated(reason = "superseded by MaybeUninit, removal planned", since = "1.38.0")]
pub fn uninit<T>() -> T;
/// Moves a value out of scope without running drop glue.
///
/// The volatile parameter is set to `true`, so it will not be optimized out
/// unless size is equal to zero.
- pub fn volatile_copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T,
- count: usize);
+ pub 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
/// `min_align_of::<T>()`
/// https://github.com/rust-lang/rust/issues/10184
pub fn float_to_int_approx_unchecked<Float, Int>(value: Float) -> Int;
-
/// Returns the number of bits set in an integer type `T`
#[rustc_const_stable(feature = "const_ctpop", since = "1.40.0")]
pub fn ctpop<T>(x: T) -> T;
/// let num_leading = unsafe { ctlz_nonzero(x) };
/// assert_eq!(num_leading, 3);
/// ```
- #[rustc_const_unstable(feature = "constctlz", issue = "0")]
+ #[rustc_const_unstable(feature = "constctlz", issue = "none")]
pub fn ctlz_nonzero<T>(x: T) -> T;
/// Returns the number of trailing unset bits (zeroes) in an integer type `T`.
/// let num_trailing = unsafe { cttz_nonzero(x) };
/// assert_eq!(num_trailing, 3);
/// ```
- #[rustc_const_unstable(feature = "const_cttz", issue = "0")]
+ #[rustc_const_unstable(feature = "const_cttz", issue = "none")]
pub fn cttz_nonzero<T>(x: T) -> T;
/// Reverses the bytes in an integer type `T`.
/// Performs rotate right.
/// The stabilized versions of this intrinsic are available on the integer
/// primitives via the `rotate_right` method. For example,
- /// [`std::u32::rotate_right`](../../std/primitive.u32.html#method.rotate_right
+ /// [`std::u32::rotate_right`](../../std/primitive.u32.html#method.rotate_right)
#[rustc_const_stable(feature = "const_int_rotate", since = "1.40.0")]
pub fn rotate_right<T>(x: T, y: T) -> T;
pub fn nontemporal_store<T>(ptr: *mut T, val: T);
/// See documentation of `<*const T>::offset_from` for details.
- #[rustc_const_unstable(feature = "const_ptr_offset_from", issue = "0")]
+ #[rustc_const_unstable(feature = "const_ptr_offset_from", issue = "none")]
pub fn ptr_offset_from<T>(ptr: *const T, base: *const T) -> isize;
/// Internal hook used by Miri to implement unwinding.
let src_usize = src as usize;
let dst_usize = dst as usize;
let size = mem::size_of::<T>().checked_mul(count).unwrap();
- let diff = if src_usize > dst_usize {
- src_usize - dst_usize
- } else {
- dst_usize - src_usize
- };
+ let diff = if src_usize > dst_usize { src_usize - dst_usize } else { dst_usize - src_usize };
size > diff
}
projects / rust.git / blobdiff