core :: core_arch :: arch :: loongarch64 :: lasx :: m256i

Struct `m256i`

#[repr(simd)]
pub struct m256i(pub(in ::core_arch::loongarch64::lasx::types) [i64; 4]);

256-bit wide integer vector type, LoongArch-specific

This type is the same as the __m256i type defined in lasxintrin.h, representing a 256-bit SIMD register. Usage of this type typically occurs in conjunction with the lasx target features for LoongArch.

Internally this type may be viewed as:

i8x32 - thirty two i8 values packed together
i16x16 - sixteen i16 values packed together
i32x8 - eight i32 values packed together
i64x4 - four i64 values packed together

(as well as unsigned versions). Each intrinsic may interpret the internal bits differently, check the documentation of the intrinsic to see how it's being used.

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.

Note that this means that an instance of m256i typically just means a "bag of bits" which is left up to interpretation at the point of use.

Most intrinsics using m256i are prefixed with lasx_ and the integer types tend to correspond to suffixes like "b", "h", "w" or "d".

Fields

0: [i64; 4]

Implementations

`impl m256i`

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

Trait Implementations

`impl Clone for m256i`

fn clone(&self) -> m256i

`impl Copy for m256i`

`impl Debug for m256i`

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

`impl From<Simd<i64, 4>> for m256i`

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

`impl TrivialClone for m256i`

Auto Trait Implementations

`impl Freeze for m256i`

`impl RefUnwindSafe for m256i`

`impl Send for m256i`

`impl Sync for m256i`

`impl Unpin for m256i`

`impl UnsafeUnpin for m256i`

`impl UnwindSafe for m256i`

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

`impl<T> From<T> for m256i`

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

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

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

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

`impl<T> SizedTypeProperties for m256i`

`impl<T, U> Into for m256i 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 m256i where U: Into<T>,`

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

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

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