Files
cfg_if
lib.rs
libm
math
acos.rsacosf.rsacosh.rsacoshf.rsasin.rsasinf.rsasinh.rsasinhf.rsatan.rsatan2.rsatan2f.rsatanf.rsatanh.rsatanhf.rscbrt.rscbrtf.rsceil.rsceilf.rscopysign.rscopysignf.rscos.rscosf.rscosh.rscoshf.rserf.rserff.rsexp.rsexp10.rsexp10f.rsexp2.rsexp2f.rsexpf.rsexpm1.rsexpm1f.rsexpo2.rsfabs.rsfabsf.rsfdim.rsfdimf.rsfenv.rsfloor.rsfloorf.rsfma.rsfmaf.rsfmax.rsfmaxf.rsfmin.rsfminf.rsfmod.rsfmodf.rsfrexp.rsfrexpf.rshypot.rshypotf.rsilogb.rsilogbf.rsj0.rsj0f.rsj1.rsj1f.rsjn.rsjnf.rsk_cos.rsk_cosf.rsk_expo2.rsk_expo2f.rsk_sin.rsk_sinf.rsk_tan.rsk_tanf.rsldexp.rsldexpf.rslgamma.rslgamma_r.rslgammaf.rslgammaf_r.rslog.rslog10.rslog10f.rslog1p.rslog1pf.rslog2.rslog2f.rslogf.rsmod.rsmodf.rsmodff.rspow.rspowf.rsrem_pio2.rsrem_pio2_large.rsrem_pio2f.rsremquo.rsremquof.rsround.rsroundf.rsscalbn.rsscalbnf.rssin.rssincos.rssincosf.rssinf.rssinh.rssinhf.rssqrt.rssqrtf.rstan.rstanf.rstanh.rstanhf.rstgamma.rstgammaf.rstrunc.rstruncf.rs
lib.rs
packed_simd_2
api
cast
macros.rsv128.rsv16.rsv256.rsv32.rsv512.rsv64.rs
cmp
eq.rsord.rspartial_eq.rspartial_ord.rsvertical.rs
fmt
binary.rsdebug.rslower_hex.rsoctal.rsupper_hex.rs
from
from_array.rsfrom_vector.rs
into_bits
arch_specific.rsmacros.rsv128.rsv16.rsv256.rsv32.rsv512.rsv64.rs
math
float
abs.rsconsts.rscos.rsexp.rsln.rsmul_add.rsmul_adde.rspowf.rsrecpre.rsrsqrte.rssin.rssqrt.rssqrte.rstanh.rs
float.rs
minimal
iuf.rsmask.rsptr.rs
ops
scalar_arithmetic.rsscalar_bitwise.rsscalar_mask_bitwise.rsscalar_shifts.rsvector_arithmetic.rsvector_bitwise.rsvector_float_min_max.rsvector_int_min_max.rsvector_mask_bitwise.rsvector_neg.rsvector_rotates.rsvector_shifts.rs
ptr
gather_scatter.rs
reductions
bitwise.rsfloat_arithmetic.rsinteger_arithmetic.rsmask.rsmin_max.rs
slice
from_slice.rswrite_to_slice.rs
bit_manip.rsbitmask.rscast.rscmp.rsdefault.rsfmt.rsfrom.rshash.rsinto_bits.rsmath.rsminimal.rsops.rsptr.rsreductions.rsselect.rsshuffle.rsshuffle1_dyn.rsslice.rsswap_bytes.rs
codegen
math
float
abs.rscos.rscos_pi.rsexp.rsln.rsmacros.rsmul_add.rsmul_adde.rspowf.rssin.rssin_cos_pi.rssin_pi.rssqrt.rssqrte.rstanh.rs
float.rs
reductions
mask
x86
sse.rssse2.rs
fallback_impl.rsx86.rs
mask.rs
bit_manip.rsllvm.rsmath.rspointer_sized_int.rsreductions.rsshuffle.rsshuffle1_dyn.rsswap_bytes.rsv128.rsv16.rsv256.rsv32.rsv512.rsv64.rsvPtr.rsvSize.rs
testing
macros.rs
api.rscodegen.rslib.rsmasks.rssealed.rstesting.rsv128.rsv16.rsv256.rsv32.rsv512.rsv64.rsvPtr.rsvSize.rs
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Implementations of the `ShuffleResult` trait for the different numbers of
//! lanes and vector element types.

use crate::masks::*;
use crate::sealed::{Seal, Shuffle};

macro_rules! impl_shuffle {
    ($array:ty, $base:ty, $out:ty) => {
        impl Seal<$array> for $base {}
        impl Shuffle<$array> for $base {
            type Output = $out;
        }
    };
}

impl_shuffle! { [u32; 2], i8, crate::codegen::i8x2 }
impl_shuffle! { [u32; 4], i8, crate::codegen::i8x4 }
impl_shuffle! { [u32; 8], i8, crate::codegen::i8x8 }
impl_shuffle! { [u32; 16], i8, crate::codegen::i8x16 }
impl_shuffle! { [u32; 32], i8, crate::codegen::i8x32 }
impl_shuffle! { [u32; 64], i8, crate::codegen::i8x64 }

impl_shuffle! { [u32; 2], u8, crate::codegen::u8x2 }
impl_shuffle! { [u32; 4], u8, crate::codegen::u8x4 }
impl_shuffle! { [u32; 8], u8, crate::codegen::u8x8 }
impl_shuffle! { [u32; 16], u8, crate::codegen::u8x16 }
impl_shuffle! { [u32; 32], u8, crate::codegen::u8x32 }
impl_shuffle! { [u32; 64], u8, crate::codegen::u8x64 }

impl_shuffle! { [u32; 2], m8, crate::codegen::m8x2 }
impl_shuffle! { [u32; 4], m8, crate::codegen::m8x4 }
impl_shuffle! { [u32; 8], m8, crate::codegen::m8x8 }
impl_shuffle! { [u32; 16], m8, crate::codegen::m8x16 }
impl_shuffle! { [u32; 32], m8, crate::codegen::m8x32 }
impl_shuffle! { [u32; 64], m8, crate::codegen::m8x64 }

impl_shuffle! { [u32; 2], i16, crate::codegen::i16x2 }
impl_shuffle! { [u32; 4], i16, crate::codegen::i16x4 }
impl_shuffle! { [u32; 8], i16, crate::codegen::i16x8 }
impl_shuffle! { [u32; 16], i16, crate::codegen::i16x16 }
impl_shuffle! { [u32; 32], i16, crate::codegen::i16x32 }

impl_shuffle! { [u32; 2], u16, crate::codegen::u16x2 }
impl_shuffle! { [u32; 4], u16, crate::codegen::u16x4 }
impl_shuffle! { [u32; 8], u16, crate::codegen::u16x8 }
impl_shuffle! { [u32; 16], u16, crate::codegen::u16x16 }
impl_shuffle! { [u32; 32], u16, crate::codegen::u16x32 }

impl_shuffle! { [u32; 2], m16, crate::codegen::m16x2 }
impl_shuffle! { [u32; 4], m16, crate::codegen::m16x4 }
impl_shuffle! { [u32; 8], m16, crate::codegen::m16x8 }
impl_shuffle! { [u32; 16], m16, crate::codegen::m16x16 }

impl_shuffle! { [u32; 2], i32, crate::codegen::i32x2 }
impl_shuffle! { [u32; 4], i32, crate::codegen::i32x4 }
impl_shuffle! { [u32; 8], i32, crate::codegen::i32x8 }
impl_shuffle! { [u32; 16], i32, crate::codegen::i32x16 }

impl_shuffle! { [u32; 2], u32, crate::codegen::u32x2 }
impl_shuffle! { [u32; 4], u32, crate::codegen::u32x4 }
impl_shuffle! { [u32; 8], u32, crate::codegen::u32x8 }
impl_shuffle! { [u32; 16], u32, crate::codegen::u32x16 }

impl_shuffle! { [u32; 2], f32, crate::codegen::f32x2 }
impl_shuffle! { [u32; 4], f32, crate::codegen::f32x4 }
impl_shuffle! { [u32; 8], f32, crate::codegen::f32x8 }
impl_shuffle! { [u32; 16], f32, crate::codegen::f32x16 }

impl_shuffle! { [u32; 2], m32, crate::codegen::m32x2 }
impl_shuffle! { [u32; 4], m32, crate::codegen::m32x4 }
impl_shuffle! { [u32; 8], m32, crate::codegen::m32x8 }
impl_shuffle! { [u32; 16], m32, crate::codegen::m32x16 }

/* FIXME: 64-bit single element vector
impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 }
*/
impl_shuffle! { [u32; 2], i64, crate::codegen::i64x2 }
impl_shuffle! { [u32; 4], i64, crate::codegen::i64x4 }
impl_shuffle! { [u32; 8], i64, crate::codegen::i64x8 }

/* FIXME: 64-bit single element vector
impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 }
*/
impl_shuffle! { [u32; 2], u64, crate::codegen::u64x2 }
impl_shuffle! { [u32; 4], u64, crate::codegen::u64x4 }
impl_shuffle! { [u32; 8], u64, crate::codegen::u64x8 }

/* FIXME: 64-bit single element vector
impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 }
*/
impl_shuffle! { [u32; 2], f64, crate::codegen::f64x2 }
impl_shuffle! { [u32; 4], f64, crate::codegen::f64x4 }
impl_shuffle! { [u32; 8], f64, crate::codegen::f64x8 }

/* FIXME: 64-bit single element vector
impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 }
*/
impl_shuffle! { [u32; 2], m64, crate::codegen::m64x2 }
impl_shuffle! { [u32; 4], m64, crate::codegen::m64x4 }
impl_shuffle! { [u32; 8], m64, crate::codegen::m64x8 }

impl_shuffle! { [u32; 2], isize, crate::codegen::isizex2 }
impl_shuffle! { [u32; 4], isize, crate::codegen::isizex4 }
impl_shuffle! { [u32; 8], isize, crate::codegen::isizex8 }

impl_shuffle! { [u32; 2], usize, crate::codegen::usizex2 }
impl_shuffle! { [u32; 4], usize, crate::codegen::usizex4 }
impl_shuffle! { [u32; 8], usize, crate::codegen::usizex8 }

impl_shuffle! { [u32; 2], msize, crate::codegen::msizex2 }
impl_shuffle! { [u32; 4], msize, crate::codegen::msizex4 }
impl_shuffle! { [u32; 8], msize, crate::codegen::msizex8 }

impl<T> Seal<[u32; 2]> for *const T {}
impl<T> Shuffle<[u32; 2]> for *const T {
    type Output = crate::codegen::cptrx2<T>;
}
impl<T> Seal<[u32; 4]> for *const T {}
impl<T> Shuffle<[u32; 4]> for *const T {
    type Output = crate::codegen::cptrx4<T>;
}
impl<T> Seal<[u32; 8]> for *const T {}
impl<T> Shuffle<[u32; 8]> for *const T {
    type Output = crate::codegen::cptrx8<T>;
}

impl<T> Seal<[u32; 2]> for *mut T {}
impl<T> Shuffle<[u32; 2]> for *mut T {
    type Output = crate::codegen::mptrx2<T>;
}
impl<T> Seal<[u32; 4]> for *mut T {}
impl<T> Shuffle<[u32; 4]> for *mut T {
    type Output = crate::codegen::mptrx4<T>;
}
impl<T> Seal<[u32; 8]> for *mut T {}
impl<T> Shuffle<[u32; 8]> for *mut T {
    type Output = crate::codegen::mptrx8<T>;
}

impl_shuffle! { [u32; 1], i128, crate::codegen::i128x1 }
impl_shuffle! { [u32; 2], i128, crate::codegen::i128x2 }
impl_shuffle! { [u32; 4], i128, crate::codegen::i128x4 }

impl_shuffle! { [u32; 1], u128, crate::codegen::u128x1 }
impl_shuffle! { [u32; 2], u128, crate::codegen::u128x2 }
impl_shuffle! { [u32; 4], u128, crate::codegen::u128x4 }

impl_shuffle! { [u32; 1], m128, crate::codegen::m128x1 }
impl_shuffle! { [u32; 2], m128, crate::codegen::m128x2 }
impl_shuffle! { [u32; 4], m128, crate::codegen::m128x4 }