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 }
|
