bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

intrinsics: remove unnecessary leading underscore from argument names

Browse source
This commit is contained in:
Ralf Jung 2025-03-12 08:03:54 +01:00
parent a21d9789e2
commit cf318a79d6
34 changed files with 362 additions and 369 deletions
Download patch file Download diff file Expand all files Collapse all files

16
compiler/rustc_codegen_cranelift/example/mini_core.rs
View file

@ -624,25 +624,25 @@ pub mod intrinsics {
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn size_of<T>() -> usize; pub fn size_of<T>() -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn size_of_val<T: ?::Sized>(_val: *const T) -> usize; pub unsafe fn size_of_val<T: ?::Sized>(val: *const T) -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn min_align_of<T>() -> usize; pub fn min_align_of<T>() -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn min_align_of_val<T: ?::Sized>(_val: *const T) -> usize; pub unsafe fn min_align_of_val<T: ?::Sized>(val: *const T) -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize); pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize);
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn transmute<T, U>(_e: T) -> U; pub unsafe fn transmute<T, U>(e: T) -> U;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn ctlz_nonzero<T>(_x: T) -> u32; pub unsafe fn ctlz_nonzero<T>(x: T) -> u32;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn needs_drop<T: ?::Sized>() -> bool; pub fn needs_drop<T: ?::Sized>() -> bool;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn bitreverse<T>(_x: T) -> T; pub fn bitreverse<T>(x: T) -> T;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn bswap<T>(_x: T) -> T; pub fn bswap<T>(x: T) -> T;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize); pub unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn unreachable() -> !; pub unsafe fn unreachable() -> !;
} }

16
compiler/rustc_codegen_gcc/example/mini_core.rs
View file

@ -595,25 +595,25 @@ pub mod intrinsics {
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn size_of<T>() -> usize; pub fn size_of<T>() -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn size_of_val<T: ?::Sized>(_val: *const T) -> usize; pub unsafe fn size_of_val<T: ?::Sized>(val: *const T) -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn min_align_of<T>() -> usize; pub fn min_align_of<T>() -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn min_align_of_val<T: ?::Sized>(_val: *const T) -> usize; pub unsafe fn min_align_of_val<T: ?::Sized>(val: *const T) -> usize;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize); pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize);
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn transmute<T, U>(_e: T) -> U; pub unsafe fn transmute<T, U>(e: T) -> U;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn ctlz_nonzero<T>(_x: T) -> u32; pub unsafe fn ctlz_nonzero<T>(x: T) -> u32;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn needs_drop<T: ?::Sized>() -> bool; pub fn needs_drop<T: ?::Sized>() -> bool;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn bitreverse<T>(_x: T) -> T; pub fn bitreverse<T>(x: T) -> T;
#[rustc_intrinsic] #[rustc_intrinsic]
pub fn bswap<T>(_x: T) -> T; pub fn bswap<T>(x: T) -> T;
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize); pub unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn unreachable() -> !; pub unsafe fn unreachable() -> !;
} }

2
library/alloc/src/boxed.rs
View file

@ -239,7 +239,7 @@ pub struct Box<
/// This is the surface syntax for `box <expr>` expressions. /// This is the surface syntax for `box <expr>` expressions.
#[rustc_intrinsic] #[rustc_intrinsic]
#[unstable(feature = "liballoc_internals", issue = "none")] #[unstable(feature = "liballoc_internals", issue = "none")]
pub fn box_new<T>(_x: T) -> Box<T>; pub fn box_new<T>(x: T) -> Box<T>;
impl<T> Box<T> { impl<T> Box<T> {
/// Allocates memory on the heap and then places `x` into it. /// Allocates memory on the heap and then places `x` into it.

6
library/core/src/ffi/va_list.rs
View file

@ -306,15 +306,15 @@ impl<'f> Drop for VaListImpl<'f> {
/// `va_copy`. /// `va_copy`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
unsafe fn va_end(_ap: &mut VaListImpl<'_>); unsafe fn va_end(ap: &mut VaListImpl<'_>);
/// Copies the current location of arglist `src` to the arglist `dst`. /// Copies the current location of arglist `src` to the arglist `dst`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
unsafe fn va_copy<'f>(_dest: *mut VaListImpl<'f>, _src: &VaListImpl<'f>); unsafe fn va_copy<'f>(dest: *mut VaListImpl<'f>, src: &VaListImpl<'f>);
/// Loads an argument of type `T` from the `va_list` `ap` and increment the /// Loads an argument of type `T` from the `va_list` `ap` and increment the
/// argument `ap` points to. /// argument `ap` points to.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
unsafe fn va_arg<T: sealed_trait::VaArgSafe>(_ap: &mut VaListImpl<'_>) -> T; unsafe fn va_arg<T: sealed_trait::VaArgSafe>(ap: &mut VaListImpl<'_>) -> T;

499
library/core/src/intrinsics/mod.rs
View file

File diff suppressed because it is too large Load diff

136
library/core/src/intrinsics/simd.rs
View file

@ -11,7 +11,7 @@
/// `idx` must be in-bounds of the vector. /// `idx` must be in-bounds of the vector.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub const unsafe fn simd_insert<T, U>(_x: T, _idx: u32, _val: U) -> T; pub const unsafe fn simd_insert<T, U>(x: T, idx: u32, val: U) -> T;
/// Extracts an element from a vector. /// Extracts an element from a vector.
/// ///
@ -22,28 +22,28 @@ pub const unsafe fn simd_insert<T, U>(_x: T, _idx: u32, _val: U) -> T;
/// `idx` must be in-bounds of the vector. /// `idx` must be in-bounds of the vector.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub const unsafe fn simd_extract<T, U>(_x: T, _idx: u32) -> U; pub const unsafe fn simd_extract<T, U>(x: T, idx: u32) -> U;
/// Adds two simd vectors elementwise. /// Adds two simd vectors elementwise.
/// ///
/// `T` must be a vector of integers or floats. /// `T` must be a vector of integers or floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_add<T>(_x: T, _y: T) -> T; pub unsafe fn simd_add<T>(x: T, y: T) -> T;
/// Subtracts `rhs` from `lhs` elementwise. /// Subtracts `rhs` from `lhs` elementwise.
/// ///
/// `T` must be a vector of integers or floats. /// `T` must be a vector of integers or floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_sub<T>(_lhs: T, _rhs: T) -> T; pub unsafe fn simd_sub<T>(lhs: T, rhs: T) -> T;
/// Multiplies two simd vectors elementwise. /// Multiplies two simd vectors elementwise.
/// ///
/// `T` must be a vector of integers or floats. /// `T` must be a vector of integers or floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_mul<T>(_x: T, _y: T) -> T; pub unsafe fn simd_mul<T>(x: T, y: T) -> T;
/// Divides `lhs` by `rhs` elementwise. /// Divides `lhs` by `rhs` elementwise.
/// ///
@ -54,7 +54,7 @@ pub unsafe fn simd_mul<T>(_x: T, _y: T) -> T;
/// Additionally for signed integers, `<int>::MIN / -1` is undefined behavior. /// Additionally for signed integers, `<int>::MIN / -1` is undefined behavior.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_div<T>(_lhs: T, _rhs: T) -> T; pub unsafe fn simd_div<T>(lhs: T, rhs: T) -> T;
/// Returns remainder of two vectors elementwise. /// Returns remainder of two vectors elementwise.
/// ///
@ -65,7 +65,7 @@ pub unsafe fn simd_div<T>(_lhs: T, _rhs: T) -> T;
/// Additionally for signed integers, `<int>::MIN / -1` is undefined behavior. /// Additionally for signed integers, `<int>::MIN / -1` is undefined behavior.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_rem<T>(_lhs: T, _rhs: T) -> T; pub unsafe fn simd_rem<T>(lhs: T, rhs: T) -> T;
/// Shifts vector left elementwise, with UB on overflow. /// Shifts vector left elementwise, with UB on overflow.
/// ///
@ -78,7 +78,7 @@ pub unsafe fn simd_rem<T>(_lhs: T, _rhs: T) -> T;
/// Each element of `rhs` must be less than `<int>::BITS`. /// Each element of `rhs` must be less than `<int>::BITS`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_shl<T>(_lhs: T, _rhs: T) -> T; pub unsafe fn simd_shl<T>(lhs: T, rhs: T) -> T;
/// Shifts vector right elementwise, with UB on overflow. /// Shifts vector right elementwise, with UB on overflow.
/// ///
@ -91,28 +91,28 @@ pub unsafe fn simd_shl<T>(_lhs: T, _rhs: T) -> T;
/// Each element of `rhs` must be less than `<int>::BITS`. /// Each element of `rhs` must be less than `<int>::BITS`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_shr<T>(_lhs: T, _rhs: T) -> T; pub unsafe fn simd_shr<T>(lhs: T, rhs: T) -> T;
/// "Ands" vectors elementwise. /// "Ands" vectors elementwise.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_and<T>(_x: T, _y: T) -> T; pub unsafe fn simd_and<T>(x: T, y: T) -> T;
/// "Ors" vectors elementwise. /// "Ors" vectors elementwise.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_or<T>(_x: T, _y: T) -> T; pub unsafe fn simd_or<T>(x: T, y: T) -> T;
/// "Exclusive ors" vectors elementwise. /// "Exclusive ors" vectors elementwise.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_xor<T>(_x: T, _y: T) -> T; pub unsafe fn simd_xor<T>(x: T, y: T) -> T;
/// Numerically casts a vector, elementwise. /// Numerically casts a vector, elementwise.
/// ///
@ -133,7 +133,7 @@ pub unsafe fn simd_xor<T>(_x: T, _y: T) -> T;
/// * Be representable in the return type, after truncating off its fractional part /// * Be representable in the return type, after truncating off its fractional part
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_cast<T, U>(_x: T) -> U; pub unsafe fn simd_cast<T, U>(x: T) -> U;
/// Numerically casts a vector, elementwise. /// Numerically casts a vector, elementwise.
/// ///
@ -147,7 +147,7 @@ pub unsafe fn simd_cast<T, U>(_x: T) -> U;
/// Otherwise, truncates or extends the value, maintaining the sign for signed integers. /// Otherwise, truncates or extends the value, maintaining the sign for signed integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_as<T, U>(_x: T) -> U; pub unsafe fn simd_as<T, U>(x: T) -> U;
/// Negates a vector elementwise. /// Negates a vector elementwise.
/// ///
@ -156,14 +156,14 @@ pub unsafe fn simd_as<T, U>(_x: T) -> U;
/// Rust panics for `-<int>::Min` due to overflow, but it is not UB with this intrinsic. /// Rust panics for `-<int>::Min` due to overflow, but it is not UB with this intrinsic.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_neg<T>(_x: T) -> T; pub unsafe fn simd_neg<T>(x: T) -> T;
/// Returns absolute value of a vector, elementwise. /// Returns absolute value of a vector, elementwise.
/// ///
/// `T` must be a vector of floating-point primitive types. /// `T` must be a vector of floating-point primitive types.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fabs<T>(_x: T) -> T; pub unsafe fn simd_fabs<T>(x: T) -> T;
/// Returns the minimum of two vectors, elementwise. /// Returns the minimum of two vectors, elementwise.
/// ///
@ -172,7 +172,7 @@ pub unsafe fn simd_fabs<T>(_x: T) -> T;
/// Follows IEEE-754 `minNum` semantics. /// Follows IEEE-754 `minNum` semantics.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fmin<T>(_x: T, _y: T) -> T; pub unsafe fn simd_fmin<T>(x: T, y: T) -> T;
/// Returns the maximum of two vectors, elementwise. /// Returns the maximum of two vectors, elementwise.
/// ///
@ -181,7 +181,7 @@ pub unsafe fn simd_fmin<T>(_x: T, _y: T) -> T;
/// Follows IEEE-754 `maxNum` semantics. /// Follows IEEE-754 `maxNum` semantics.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fmax<T>(_x: T, _y: T) -> T; pub unsafe fn simd_fmax<T>(x: T, y: T) -> T;
/// Tests elementwise equality of two vectors. /// Tests elementwise equality of two vectors.
/// ///
@ -192,7 +192,7 @@ pub unsafe fn simd_fmax<T>(_x: T, _y: T) -> T;
/// Returns `0` for false and `!0` for true. /// Returns `0` for false and `!0` for true.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_eq<T, U>(_x: T, _y: T) -> U; pub unsafe fn simd_eq<T, U>(x: T, y: T) -> U;
/// Tests elementwise inequality equality of two vectors. /// Tests elementwise inequality equality of two vectors.
/// ///
@ -203,7 +203,7 @@ pub unsafe fn simd_eq<T, U>(_x: T, _y: T) -> U;
/// Returns `0` for false and `!0` for true. /// Returns `0` for false and `!0` for true.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_ne<T, U>(_x: T, _y: T) -> U; pub unsafe fn simd_ne<T, U>(x: T, y: T) -> U;
/// Tests if `x` is less than `y`, elementwise. /// Tests if `x` is less than `y`, elementwise.
/// ///
@ -214,7 +214,7 @@ pub unsafe fn simd_ne<T, U>(_x: T, _y: T) -> U;
/// Returns `0` for false and `!0` for true. /// Returns `0` for false and `!0` for true.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_lt<T, U>(_x: T, _y: T) -> U; pub unsafe fn simd_lt<T, U>(x: T, y: T) -> U;
/// Tests if `x` is less than or equal to `y`, elementwise. /// Tests if `x` is less than or equal to `y`, elementwise.
/// ///
@ -225,7 +225,7 @@ pub unsafe fn simd_lt<T, U>(_x: T, _y: T) -> U;
/// Returns `0` for false and `!0` for true. /// Returns `0` for false and `!0` for true.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_le<T, U>(_x: T, _y: T) -> U; pub unsafe fn simd_le<T, U>(x: T, y: T) -> U;
/// Tests if `x` is greater than `y`, elementwise. /// Tests if `x` is greater than `y`, elementwise.
/// ///
@ -236,7 +236,7 @@ pub unsafe fn simd_le<T, U>(_x: T, _y: T) -> U;
/// Returns `0` for false and `!0` for true. /// Returns `0` for false and `!0` for true.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_gt<T, U>(_x: T, _y: T) -> U; pub unsafe fn simd_gt<T, U>(x: T, y: T) -> U;
/// Tests if `x` is greater than or equal to `y`, elementwise. /// Tests if `x` is greater than or equal to `y`, elementwise.
/// ///
@ -247,7 +247,7 @@ pub unsafe fn simd_gt<T, U>(_x: T, _y: T) -> U;
/// Returns `0` for false and `!0` for true. /// Returns `0` for false and `!0` for true.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_ge<T, U>(_x: T, _y: T) -> U; pub unsafe fn simd_ge<T, U>(x: T, y: T) -> U;
/// Shuffles two vectors by const indices. /// Shuffles two vectors by const indices.
/// ///
@ -263,7 +263,7 @@ pub unsafe fn simd_ge<T, U>(_x: T, _y: T) -> U;
/// of `xy`. /// of `xy`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_shuffle<T, U, V>(_x: T, _y: T, _idx: U) -> V; pub unsafe fn simd_shuffle<T, U, V>(x: T, y: T, idx: U) -> V;
/// Reads a vector of pointers. /// Reads a vector of pointers.
/// ///
@ -284,7 +284,7 @@ pub unsafe fn simd_shuffle<T, U, V>(_x: T, _y: T, _idx: U) -> V;
/// `mask` must only contain `0` or `!0` values. /// `mask` must only contain `0` or `!0` values.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_gather<T, U, V>(_val: T, _ptr: U, _mask: V) -> T; pub unsafe fn simd_gather<T, U, V>(val: T, ptr: U, mask: V) -> T;
/// Writes to a vector of pointers. /// Writes to a vector of pointers.
/// ///
@ -308,7 +308,7 @@ pub unsafe fn simd_gather<T, U, V>(_val: T, _ptr: U, _mask: V) -> T;
/// `mask` must only contain `0` or `!0` values. /// `mask` must only contain `0` or `!0` values.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_scatter<T, U, V>(_val: T, _ptr: U, _mask: V); pub unsafe fn simd_scatter<T, U, V>(val: T, ptr: U, mask: V);
/// Reads a vector of pointers. /// Reads a vector of pointers.
/// ///
@ -331,7 +331,7 @@ pub unsafe fn simd_scatter<T, U, V>(_val: T, _ptr: U, _mask: V);
/// `mask` must only contain `0` or `!0` values. /// `mask` must only contain `0` or `!0` values.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_masked_load<V, U, T>(_mask: V, _ptr: U, _val: T) -> T; pub unsafe fn simd_masked_load<V, U, T>(mask: V, ptr: U, val: T) -> T;
/// Writes to a vector of pointers. /// Writes to a vector of pointers.
/// ///
@ -353,14 +353,14 @@ pub unsafe fn simd_masked_load<V, U, T>(_mask: V, _ptr: U, _val: T) -> T;
/// `mask` must only contain `0` or `!0` values. /// `mask` must only contain `0` or `!0` values.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_masked_store<V, U, T>(_mask: V, _ptr: U, _val: T); pub unsafe fn simd_masked_store<V, U, T>(mask: V, ptr: U, val: T);
/// Adds two simd vectors elementwise, with saturation. /// Adds two simd vectors elementwise, with saturation.
/// ///
/// `T` must be a vector of integer primitive types. /// `T` must be a vector of integer primitive types.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_saturating_add<T>(_x: T, _y: T) -> T; pub unsafe fn simd_saturating_add<T>(x: T, y: T) -> T;
/// Subtracts two simd vectors elementwise, with saturation. /// Subtracts two simd vectors elementwise, with saturation.
/// ///
@ -369,7 +369,7 @@ pub unsafe fn simd_saturating_add<T>(_x: T, _y: T) -> T;
/// Subtract `rhs` from `lhs`. /// Subtract `rhs` from `lhs`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_saturating_sub<T>(_lhs: T, _rhs: T) -> T; pub unsafe fn simd_saturating_sub<T>(lhs: T, rhs: T) -> T;
/// Adds elements within a vector from left to right. /// Adds elements within a vector from left to right.
/// ///
@ -380,7 +380,7 @@ pub unsafe fn simd_saturating_sub<T>(_lhs: T, _rhs: T) -> T;
/// Starting with the value `y`, add the elements of `x` and accumulate. /// Starting with the value `y`, add the elements of `x` and accumulate.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_add_ordered<T, U>(_x: T, _y: U) -> U; pub unsafe fn simd_reduce_add_ordered<T, U>(x: T, y: U) -> U;
/// Adds elements within a vector in arbitrary order. May also be re-associated with /// Adds elements within a vector in arbitrary order. May also be re-associated with
/// unordered additions on the inputs/outputs. /// unordered additions on the inputs/outputs.
@ -390,7 +390,7 @@ pub unsafe fn simd_reduce_add_ordered<T, U>(_x: T, _y: U) -> U;
/// `U` must be the element type of `T`. /// `U` must be the element type of `T`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_add_unordered<T, U>(_x: T) -> U; pub unsafe fn simd_reduce_add_unordered<T, U>(x: T) -> U;
/// Multiplies elements within a vector from left to right. /// Multiplies elements within a vector from left to right.
/// ///
@ -401,7 +401,7 @@ pub unsafe fn simd_reduce_add_unordered<T, U>(_x: T) -> U;
/// Starting with the value `y`, multiply the elements of `x` and accumulate. /// Starting with the value `y`, multiply the elements of `x` and accumulate.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_mul_ordered<T, U>(_x: T, _y: U) -> U; pub unsafe fn simd_reduce_mul_ordered<T, U>(x: T, y: U) -> U;
/// Multiplies elements within a vector in arbitrary order. May also be re-associated with /// Multiplies elements within a vector in arbitrary order. May also be re-associated with
/// unordered additions on the inputs/outputs. /// unordered additions on the inputs/outputs.
@ -411,7 +411,7 @@ pub unsafe fn simd_reduce_mul_ordered<T, U>(_x: T, _y: U) -> U;
/// `U` must be the element type of `T`. /// `U` must be the element type of `T`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_mul_unordered<T, U>(_x: T) -> U; pub unsafe fn simd_reduce_mul_unordered<T, U>(x: T) -> U;
/// Checks if all mask values are true. /// Checks if all mask values are true.
/// ///
@ -421,7 +421,7 @@ pub unsafe fn simd_reduce_mul_unordered<T, U>(_x: T) -> U;
/// `x` must contain only `0` or `!0`. /// `x` must contain only `0` or `!0`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_all<T>(_x: T) -> bool; pub unsafe fn simd_reduce_all<T>(x: T) -> bool;
/// Checks if any mask value is true. /// Checks if any mask value is true.
/// ///
@ -431,7 +431,7 @@ pub unsafe fn simd_reduce_all<T>(_x: T) -> bool;
/// `x` must contain only `0` or `!0`. /// `x` must contain only `0` or `!0`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_any<T>(_x: T) -> bool; pub unsafe fn simd_reduce_any<T>(x: T) -> bool;
/// Returns the maximum element of a vector. /// Returns the maximum element of a vector.
/// ///
@ -442,7 +442,7 @@ pub unsafe fn simd_reduce_any<T>(_x: T) -> bool;
/// For floating-point values, uses IEEE-754 `maxNum`. /// For floating-point values, uses IEEE-754 `maxNum`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_max<T, U>(_x: T) -> U; pub unsafe fn simd_reduce_max<T, U>(x: T) -> U;
/// Returns the minimum element of a vector. /// Returns the minimum element of a vector.
/// ///
@ -453,7 +453,7 @@ pub unsafe fn simd_reduce_max<T, U>(_x: T) -> U;
/// For floating-point values, uses IEEE-754 `minNum`. /// For floating-point values, uses IEEE-754 `minNum`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_min<T, U>(_x: T) -> U; pub unsafe fn simd_reduce_min<T, U>(x: T) -> U;
/// Logical "ands" all elements together. /// Logical "ands" all elements together.
/// ///
@ -462,7 +462,7 @@ pub unsafe fn simd_reduce_min<T, U>(_x: T) -> U;
/// `U` must be the element type of `T`. /// `U` must be the element type of `T`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_and<T, U>(_x: T) -> U; pub unsafe fn simd_reduce_and<T, U>(x: T) -> U;
/// Logical "ors" all elements together. /// Logical "ors" all elements together.
/// ///
@ -471,7 +471,7 @@ pub unsafe fn simd_reduce_and<T, U>(_x: T) -> U;
/// `U` must be the element type of `T`. /// `U` must be the element type of `T`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_or<T, U>(_x: T) -> U; pub unsafe fn simd_reduce_or<T, U>(x: T) -> U;
/// Logical "exclusive ors" all elements together. /// Logical "exclusive ors" all elements together.
/// ///
@ -480,7 +480,7 @@ pub unsafe fn simd_reduce_or<T, U>(_x: T) -> U;
/// `U` must be the element type of `T`. /// `U` must be the element type of `T`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_reduce_xor<T, U>(_x: T) -> U; pub unsafe fn simd_reduce_xor<T, U>(x: T) -> U;
/// Truncates an integer vector to a bitmask. /// Truncates an integer vector to a bitmask.
/// ///
@ -517,7 +517,7 @@ pub unsafe fn simd_reduce_xor<T, U>(_x: T) -> U;
/// `x` must contain only `0` and `!0`. /// `x` must contain only `0` and `!0`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_bitmask<T, U>(_x: T) -> U; pub unsafe fn simd_bitmask<T, U>(x: T) -> U;
/// Selects elements from a mask. /// Selects elements from a mask.
/// ///
@ -533,7 +533,7 @@ pub unsafe fn simd_bitmask<T, U>(_x: T) -> U;
/// `mask` must only contain `0` and `!0`. /// `mask` must only contain `0` and `!0`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_select<M, T>(_mask: M, _if_true: T, _if_false: T) -> T; pub unsafe fn simd_select<M, T>(mask: M, if_true: T, if_false: T) -> T;
/// Selects elements from a bitmask. /// Selects elements from a bitmask.
/// ///
@ -551,7 +551,7 @@ pub unsafe fn simd_select<M, T>(_mask: M, _if_true: T, _if_false: T) -> T;
/// Padding bits must be all zero. /// Padding bits must be all zero.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_select_bitmask<M, T>(_m: M, _yes: T, _no: T) -> T; pub unsafe fn simd_select_bitmask<M, T>(m: M, yes: T, no: T) -> T;
/// Calculates the offset from a pointer vector elementwise, potentially /// Calculates the offset from a pointer vector elementwise, potentially
/// wrapping. /// wrapping.
@ -563,14 +563,14 @@ pub unsafe fn simd_select_bitmask<M, T>(_m: M, _yes: T, _no: T) -> T;
/// Operates as if by `<ptr>::wrapping_offset`. /// Operates as if by `<ptr>::wrapping_offset`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_arith_offset<T, U>(_ptr: T, _offset: U) -> T; pub unsafe fn simd_arith_offset<T, U>(ptr: T, offset: U) -> T;
/// Casts a vector of pointers. /// Casts a vector of pointers.
/// ///
/// `T` and `U` must be vectors of pointers with the same number of elements. /// `T` and `U` must be vectors of pointers with the same number of elements.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_cast_ptr<T, U>(_ptr: T) -> U; pub unsafe fn simd_cast_ptr<T, U>(ptr: T) -> U;
/// Exposes a vector of pointers as a vector of addresses. /// Exposes a vector of pointers as a vector of addresses.
/// ///
@ -579,7 +579,7 @@ pub unsafe fn simd_cast_ptr<T, U>(_ptr: T) -> U;
/// `U` must be a vector of `usize` with the same length as `T`. /// `U` must be a vector of `usize` with the same length as `T`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_expose_provenance<T, U>(_ptr: T) -> U; pub unsafe fn simd_expose_provenance<T, U>(ptr: T) -> U;
/// Creates a vector of pointers from a vector of addresses. /// Creates a vector of pointers from a vector of addresses.
/// ///
@ -588,56 +588,56 @@ pub unsafe fn simd_expose_provenance<T, U>(_ptr: T) -> U;
/// `U` must be a vector of pointers, with the same length as `T`. /// `U` must be a vector of pointers, with the same length as `T`.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_with_exposed_provenance<T, U>(_addr: T) -> U; pub unsafe fn simd_with_exposed_provenance<T, U>(addr: T) -> U;
/// Swaps bytes of each element. /// Swaps bytes of each element.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_bswap<T>(_x: T) -> T; pub unsafe fn simd_bswap<T>(x: T) -> T;
/// Reverses bits of each element. /// Reverses bits of each element.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_bitreverse<T>(_x: T) -> T; pub unsafe fn simd_bitreverse<T>(x: T) -> T;
/// Counts the leading zeros of each element. /// Counts the leading zeros of each element.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_ctlz<T>(_x: T) -> T; pub unsafe fn simd_ctlz<T>(x: T) -> T;
/// Counts the number of ones in each element. /// Counts the number of ones in each element.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_ctpop<T>(_x: T) -> T; pub unsafe fn simd_ctpop<T>(x: T) -> T;
/// Counts the trailing zeros of each element. /// Counts the trailing zeros of each element.
/// ///
/// `T` must be a vector of integers. /// `T` must be a vector of integers.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_cttz<T>(_x: T) -> T; pub unsafe fn simd_cttz<T>(x: T) -> T;
/// Rounds up each element to the next highest integer-valued float. /// Rounds up each element to the next highest integer-valued float.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_ceil<T>(_x: T) -> T; pub unsafe fn simd_ceil<T>(x: T) -> T;
/// Rounds down each element to the next lowest integer-valued float. /// Rounds down each element to the next lowest integer-valued float.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_floor<T>(_x: T) -> T; pub unsafe fn simd_floor<T>(x: T) -> T;
/// Rounds each element to the closest integer-valued float. /// Rounds each element to the closest integer-valued float.
/// Ties are resolved by rounding away from 0. /// Ties are resolved by rounding away from 0.
@ -645,7 +645,7 @@ pub unsafe fn simd_floor<T>(_x: T) -> T;
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_round<T>(_x: T) -> T; pub unsafe fn simd_round<T>(x: T) -> T;
/// Returns the integer part of each element as an integer-valued float. /// Returns the integer part of each element as an integer-valued float.
/// In other words, non-integer values are truncated towards zero. /// In other words, non-integer values are truncated towards zero.
@ -653,21 +653,21 @@ pub unsafe fn simd_round<T>(_x: T) -> T;
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_trunc<T>(_x: T) -> T; pub unsafe fn simd_trunc<T>(x: T) -> T;
/// Takes the square root of each element. /// Takes the square root of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fsqrt<T>(_x: T) -> T; pub unsafe fn simd_fsqrt<T>(x: T) -> T;
/// Computes `(x*y) + z` for each element, but without any intermediate rounding. /// Computes `(x*y) + z` for each element, but without any intermediate rounding.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fma<T>(_x: T, _y: T, _z: T) -> T; pub unsafe fn simd_fma<T>(x: T, y: T, z: T) -> T;
/// Computes `(x*y) + z` for each element, non-deterministically executing either /// Computes `(x*y) + z` for each element, non-deterministically executing either
/// a fused multiply-add or two operations with rounding of the intermediate result. /// a fused multiply-add or two operations with rounding of the intermediate result.
@ -682,53 +682,53 @@ pub unsafe fn simd_fma<T>(_x: T, _y: T, _z: T) -> T;
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_relaxed_fma<T>(_x: T, _y: T, _z: T) -> T; pub unsafe fn simd_relaxed_fma<T>(x: T, y: T, z: T) -> T;
// Computes the sine of each element. // Computes the sine of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fsin<T>(_a: T) -> T; pub unsafe fn simd_fsin<T>(a: T) -> T;
// Computes the cosine of each element. // Computes the cosine of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fcos<T>(_a: T) -> T; pub unsafe fn simd_fcos<T>(a: T) -> T;
// Computes the exponential function of each element. // Computes the exponential function of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fexp<T>(_a: T) -> T; pub unsafe fn simd_fexp<T>(a: T) -> T;
// Computes 2 raised to the power of each element. // Computes 2 raised to the power of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_fexp2<T>(_a: T) -> T; pub unsafe fn simd_fexp2<T>(a: T) -> T;
// Computes the base 10 logarithm of each element. // Computes the base 10 logarithm of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_flog10<T>(_a: T) -> T; pub unsafe fn simd_flog10<T>(a: T) -> T;
// Computes the base 2 logarithm of each element. // Computes the base 2 logarithm of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_flog2<T>(_a: T) -> T; pub unsafe fn simd_flog2<T>(a: T) -> T;
// Computes the natural logarithm of each element. // Computes the natural logarithm of each element.
/// ///
/// `T` must be a vector of floats. /// `T` must be a vector of floats.
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_flog<T>(_a: T) -> T; pub unsafe fn simd_flog<T>(a: T) -> T;

2
src/tools/miri/tests/fail/intrinsics/copy_overlapping.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn copy_nonoverlapping<T>(_src: *const T, _dst: *mut T, _count: usize); unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
fn main() { fn main() {
let mut data = [0u8; 16]; let mut data = [0u8; 16];

2
src/tools/miri/tests/fail/intrinsics/copy_unaligned.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn copy_nonoverlapping<T>(_src: *const T, _dst: *mut T, _count: usize); unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
fn main() { fn main() {
let mut data = [0u16; 8]; let mut data = [0u16; 8];

2
src/tools/miri/tests/fail/intrinsics/ctlz_nonzero.rs
View file

@ -2,7 +2,7 @@
mod rusti { mod rusti {
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn ctlz_nonzero<T>(_x: T) -> u32; pub unsafe fn ctlz_nonzero<T>(x: T) -> u32;
} }
pub fn main() { pub fn main() {

2
src/tools/miri/tests/fail/intrinsics/cttz_nonzero.rs
View file

@ -2,7 +2,7 @@
mod rusti { mod rusti {
#[rustc_intrinsic] #[rustc_intrinsic]
pub unsafe fn cttz_nonzero<T>(_x: T) -> u32; pub unsafe fn cttz_nonzero<T>(x: T) -> u32;
} }
pub fn main() { pub fn main() {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_inf1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_infneg1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_nan.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_nanneg.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_neg.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_big2.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_32_too_small1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_inf1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_infneg2.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_nan.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_neg.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big2.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big3.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big4.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big5.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big6.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_big7.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small1.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small2.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/fail/intrinsics/float_to_int_64_too_small3.rs
View file

@ -2,7 +2,7 @@
// Directly call intrinsic to avoid debug assertions in libstd // Directly call intrinsic to avoid debug assertions in libstd
#[rustc_intrinsic] #[rustc_intrinsic]
unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int; unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(value: Float) -> Int;
fn main() { fn main() {
unsafe { unsafe {

2
src/tools/miri/tests/pass/intrinsics/portable-simd.rs
View file

@ -16,7 +16,7 @@ use std::simd::prelude::*;
#[rustc_intrinsic] #[rustc_intrinsic]
#[rustc_nounwind] #[rustc_nounwind]
pub unsafe fn simd_shuffle_const_generic<T, U, const IDX: &'static [u32]>(_x: T, _y: T) -> U; pub unsafe fn simd_shuffle_const_generic<T, U, const IDX: &'static [u32]>(x: T, y: T) -> U;
fn simd_ops_f32() { fn simd_ops_f32() {
let a = f32x4::splat(10.0); let a = f32x4::splat(10.0);