core :: core_arch :: arch :: loongarch64 :: lsx :: m128

Struct `m128`

#[repr(simd)]
pub struct m128(pub(in ::core_arch::loongarch64::lsx::types) [f32; 4]);

128-bit wide set of four f32 values, LoongArch-specific

This type is the same as the __m128 type defined in lsxintrin.h, representing a 128-bit SIMD register which internally consists of four packed f32 instances. Usage of this type typically occurs in conjunction with the lsx and higher target features for LoongArch.

Note that unlike m128i, the integer version of the 128-bit registers, this m128 type has one interpretation. Each instance of m128 corresponds to f32x4, or four f32 values packed together.

The in-memory representation of this type is the same as the one of an equivalent array (i.e. the in-memory order of elements is the same, and there is no padding); however, the alignment is different and equal to the size of the type. Note that the ABI for function calls may not be the same.

Most intrinsics using m128 are prefixed with lsx_ and are suffixed with "s".

Fields

0: [f32; 4]

Implementations

`impl m128`

fn splat(value: f32) -> m128: Put the same value in every lane.
const fn as_array(&self) -> &[f32; 4]: Returns an array reference containing the entire SIMD vector.
fn as_mut_array(&mut self) -> &mut [f32; 4]: Returns a mutable array reference containing the entire SIMD vector.

Trait Implementations

`impl Clone for m128`

fn clone(&self) -> m128

`impl Copy for m128`

`impl Debug for m128`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

`impl From<Simd<f32, 4>> for m128`

fn from(simd: Simd<f32, 4>) -> Self

`impl TrivialClone for m128`

Auto Trait Implementations

`impl Freeze for m128`

`impl RefUnwindSafe for m128`

`impl Send for m128`

`impl Sync for m128`

`impl Unpin for m128`

`impl UnsafeUnpin for m128`

`impl UnwindSafe for m128`

Blanket Implementations

`impl<T> Any for m128 where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for m128 where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for m128 where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for m128 where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for m128`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Printable for m128 where T: Copy + Debug,`

`impl<T> SizeHint for m128 where T: ?Sized,`

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

`impl<T> SizedTypeProperties for m128`

`impl<T, U> Into for m128 where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for m128 where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for m128 where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>