1 // RUN: %clang_cc1 -triple arm64-none-linux-gnu -target-feature +neon \
2 // RUN: -disable-O0-optnone -emit-llvm -o - %s | opt -S -passes=mem2reg | FileCheck %s
4 // REQUIRES: aarch64-registered-target || arm-registered-target
8 // CHECK-LABEL: @test_vuzp1_s8(
9 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
10 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
11 int8x8_t
test_vuzp1_s8(int8x8_t a
, int8x8_t b
) {
12 return vuzp1_s8(a
, b
);
15 // CHECK-LABEL: @test_vuzp1q_s8(
16 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
17 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
18 int8x16_t
test_vuzp1q_s8(int8x16_t a
, int8x16_t b
) {
19 return vuzp1q_s8(a
, b
);
22 // CHECK-LABEL: @test_vuzp1_s16(
23 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
24 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
25 int16x4_t
test_vuzp1_s16(int16x4_t a
, int16x4_t b
) {
26 return vuzp1_s16(a
, b
);
29 // CHECK-LABEL: @test_vuzp1q_s16(
30 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
31 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
32 int16x8_t
test_vuzp1q_s16(int16x8_t a
, int16x8_t b
) {
33 return vuzp1q_s16(a
, b
);
36 // CHECK-LABEL: @test_vuzp1_s32(
37 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
38 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
39 int32x2_t
test_vuzp1_s32(int32x2_t a
, int32x2_t b
) {
40 return vuzp1_s32(a
, b
);
43 // CHECK-LABEL: @test_vuzp1q_s32(
44 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
45 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
46 int32x4_t
test_vuzp1q_s32(int32x4_t a
, int32x4_t b
) {
47 return vuzp1q_s32(a
, b
);
50 // CHECK-LABEL: @test_vuzp1q_s64(
51 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
52 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
53 int64x2_t
test_vuzp1q_s64(int64x2_t a
, int64x2_t b
) {
54 return vuzp1q_s64(a
, b
);
57 // CHECK-LABEL: @test_vuzp1_u8(
58 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
59 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
60 uint8x8_t
test_vuzp1_u8(uint8x8_t a
, uint8x8_t b
) {
61 return vuzp1_u8(a
, b
);
64 // CHECK-LABEL: @test_vuzp1q_u8(
65 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
66 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
67 uint8x16_t
test_vuzp1q_u8(uint8x16_t a
, uint8x16_t b
) {
68 return vuzp1q_u8(a
, b
);
71 // CHECK-LABEL: @test_vuzp1_u16(
72 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
73 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
74 uint16x4_t
test_vuzp1_u16(uint16x4_t a
, uint16x4_t b
) {
75 return vuzp1_u16(a
, b
);
78 // CHECK-LABEL: @test_vuzp1q_u16(
79 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
80 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
81 uint16x8_t
test_vuzp1q_u16(uint16x8_t a
, uint16x8_t b
) {
82 return vuzp1q_u16(a
, b
);
85 // CHECK-LABEL: @test_vuzp1_u32(
86 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
87 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
88 uint32x2_t
test_vuzp1_u32(uint32x2_t a
, uint32x2_t b
) {
89 return vuzp1_u32(a
, b
);
92 // CHECK-LABEL: @test_vuzp1q_u32(
93 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
94 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
95 uint32x4_t
test_vuzp1q_u32(uint32x4_t a
, uint32x4_t b
) {
96 return vuzp1q_u32(a
, b
);
99 // CHECK-LABEL: @test_vuzp1q_u64(
100 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
101 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
102 uint64x2_t
test_vuzp1q_u64(uint64x2_t a
, uint64x2_t b
) {
103 return vuzp1q_u64(a
, b
);
106 // CHECK-LABEL: @test_vuzp1_f32(
107 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
108 // CHECK: ret <2 x float> [[SHUFFLE_I]]
109 float32x2_t
test_vuzp1_f32(float32x2_t a
, float32x2_t b
) {
110 return vuzp1_f32(a
, b
);
113 // CHECK-LABEL: @test_vuzp1q_f32(
114 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
115 // CHECK: ret <4 x float> [[SHUFFLE_I]]
116 float32x4_t
test_vuzp1q_f32(float32x4_t a
, float32x4_t b
) {
117 return vuzp1q_f32(a
, b
);
120 // CHECK-LABEL: @test_vuzp1q_f64(
121 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 0, i32 2>
122 // CHECK: ret <2 x double> [[SHUFFLE_I]]
123 float64x2_t
test_vuzp1q_f64(float64x2_t a
, float64x2_t b
) {
124 return vuzp1q_f64(a
, b
);
127 // CHECK-LABEL: @test_vuzp1_p8(
128 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
129 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
130 poly8x8_t
test_vuzp1_p8(poly8x8_t a
, poly8x8_t b
) {
131 return vuzp1_p8(a
, b
);
134 // CHECK-LABEL: @test_vuzp1q_p8(
135 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
136 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
137 poly8x16_t
test_vuzp1q_p8(poly8x16_t a
, poly8x16_t b
) {
138 return vuzp1q_p8(a
, b
);
141 // CHECK-LABEL: @test_vuzp1_p16(
142 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
143 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
144 poly16x4_t
test_vuzp1_p16(poly16x4_t a
, poly16x4_t b
) {
145 return vuzp1_p16(a
, b
);
148 // CHECK-LABEL: @test_vuzp1q_p16(
149 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
150 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
151 poly16x8_t
test_vuzp1q_p16(poly16x8_t a
, poly16x8_t b
) {
152 return vuzp1q_p16(a
, b
);
155 // CHECK-LABEL: @test_vuzp2_s8(
156 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
157 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
158 int8x8_t
test_vuzp2_s8(int8x8_t a
, int8x8_t b
) {
159 return vuzp2_s8(a
, b
);
162 // CHECK-LABEL: @test_vuzp2q_s8(
163 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
164 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
165 int8x16_t
test_vuzp2q_s8(int8x16_t a
, int8x16_t b
) {
166 return vuzp2q_s8(a
, b
);
169 // CHECK-LABEL: @test_vuzp2_s16(
170 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
171 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
172 int16x4_t
test_vuzp2_s16(int16x4_t a
, int16x4_t b
) {
173 return vuzp2_s16(a
, b
);
176 // CHECK-LABEL: @test_vuzp2q_s16(
177 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
178 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
179 int16x8_t
test_vuzp2q_s16(int16x8_t a
, int16x8_t b
) {
180 return vuzp2q_s16(a
, b
);
183 // CHECK-LABEL: @test_vuzp2_s32(
184 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
185 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
186 int32x2_t
test_vuzp2_s32(int32x2_t a
, int32x2_t b
) {
187 return vuzp2_s32(a
, b
);
190 // CHECK-LABEL: @test_vuzp2q_s32(
191 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
192 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
193 int32x4_t
test_vuzp2q_s32(int32x4_t a
, int32x4_t b
) {
194 return vuzp2q_s32(a
, b
);
197 // CHECK-LABEL: @test_vuzp2q_s64(
198 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
199 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
200 int64x2_t
test_vuzp2q_s64(int64x2_t a
, int64x2_t b
) {
201 return vuzp2q_s64(a
, b
);
204 // CHECK-LABEL: @test_vuzp2_u8(
205 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
206 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
207 uint8x8_t
test_vuzp2_u8(uint8x8_t a
, uint8x8_t b
) {
208 return vuzp2_u8(a
, b
);
211 // CHECK-LABEL: @test_vuzp2q_u8(
212 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
213 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
214 uint8x16_t
test_vuzp2q_u8(uint8x16_t a
, uint8x16_t b
) {
215 return vuzp2q_u8(a
, b
);
218 // CHECK-LABEL: @test_vuzp2_u16(
219 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
220 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
221 uint16x4_t
test_vuzp2_u16(uint16x4_t a
, uint16x4_t b
) {
222 return vuzp2_u16(a
, b
);
225 // CHECK-LABEL: @test_vuzp2q_u16(
226 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
227 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
228 uint16x8_t
test_vuzp2q_u16(uint16x8_t a
, uint16x8_t b
) {
229 return vuzp2q_u16(a
, b
);
232 // CHECK-LABEL: @test_vuzp2_u32(
233 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
234 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
235 uint32x2_t
test_vuzp2_u32(uint32x2_t a
, uint32x2_t b
) {
236 return vuzp2_u32(a
, b
);
239 // CHECK-LABEL: @test_vuzp2q_u32(
240 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
241 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
242 uint32x4_t
test_vuzp2q_u32(uint32x4_t a
, uint32x4_t b
) {
243 return vuzp2q_u32(a
, b
);
246 // CHECK-LABEL: @test_vuzp2q_u64(
247 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
248 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
249 uint64x2_t
test_vuzp2q_u64(uint64x2_t a
, uint64x2_t b
) {
250 return vuzp2q_u64(a
, b
);
253 // CHECK-LABEL: @test_vuzp2_f32(
254 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
255 // CHECK: ret <2 x float> [[SHUFFLE_I]]
256 float32x2_t
test_vuzp2_f32(float32x2_t a
, float32x2_t b
) {
257 return vuzp2_f32(a
, b
);
260 // CHECK-LABEL: @test_vuzp2q_f32(
261 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
262 // CHECK: ret <4 x float> [[SHUFFLE_I]]
263 float32x4_t
test_vuzp2q_f32(float32x4_t a
, float32x4_t b
) {
264 return vuzp2q_f32(a
, b
);
267 // CHECK-LABEL: @test_vuzp2q_f64(
268 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 1, i32 3>
269 // CHECK: ret <2 x double> [[SHUFFLE_I]]
270 float64x2_t
test_vuzp2q_f64(float64x2_t a
, float64x2_t b
) {
271 return vuzp2q_f64(a
, b
);
274 // CHECK-LABEL: @test_vuzp2_p8(
275 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
276 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
277 poly8x8_t
test_vuzp2_p8(poly8x8_t a
, poly8x8_t b
) {
278 return vuzp2_p8(a
, b
);
281 // CHECK-LABEL: @test_vuzp2q_p8(
282 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
283 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
284 poly8x16_t
test_vuzp2q_p8(poly8x16_t a
, poly8x16_t b
) {
285 return vuzp2q_p8(a
, b
);
288 // CHECK-LABEL: @test_vuzp2_p16(
289 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
290 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
291 poly16x4_t
test_vuzp2_p16(poly16x4_t a
, poly16x4_t b
) {
292 return vuzp2_p16(a
, b
);
295 // CHECK-LABEL: @test_vuzp2q_p16(
296 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
297 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
298 poly16x8_t
test_vuzp2q_p16(poly16x8_t a
, poly16x8_t b
) {
299 return vuzp2q_p16(a
, b
);
302 // CHECK-LABEL: @test_vzip1_s8(
303 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
304 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
305 int8x8_t
test_vzip1_s8(int8x8_t a
, int8x8_t b
) {
306 return vzip1_s8(a
, b
);
309 // CHECK-LABEL: @test_vzip1q_s8(
310 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
311 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
312 int8x16_t
test_vzip1q_s8(int8x16_t a
, int8x16_t b
) {
313 return vzip1q_s8(a
, b
);
316 // CHECK-LABEL: @test_vzip1_s16(
317 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
318 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
319 int16x4_t
test_vzip1_s16(int16x4_t a
, int16x4_t b
) {
320 return vzip1_s16(a
, b
);
323 // CHECK-LABEL: @test_vzip1q_s16(
324 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
325 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
326 int16x8_t
test_vzip1q_s16(int16x8_t a
, int16x8_t b
) {
327 return vzip1q_s16(a
, b
);
330 // CHECK-LABEL: @test_vzip1_s32(
331 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
332 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
333 int32x2_t
test_vzip1_s32(int32x2_t a
, int32x2_t b
) {
334 return vzip1_s32(a
, b
);
337 // CHECK-LABEL: @test_vzip1q_s32(
338 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
339 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
340 int32x4_t
test_vzip1q_s32(int32x4_t a
, int32x4_t b
) {
341 return vzip1q_s32(a
, b
);
344 // CHECK-LABEL: @test_vzip1q_s64(
345 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
346 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
347 int64x2_t
test_vzip1q_s64(int64x2_t a
, int64x2_t b
) {
348 return vzip1q_s64(a
, b
);
351 // CHECK-LABEL: @test_vzip1_u8(
352 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
353 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
354 uint8x8_t
test_vzip1_u8(uint8x8_t a
, uint8x8_t b
) {
355 return vzip1_u8(a
, b
);
358 // CHECK-LABEL: @test_vzip1q_u8(
359 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
360 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
361 uint8x16_t
test_vzip1q_u8(uint8x16_t a
, uint8x16_t b
) {
362 return vzip1q_u8(a
, b
);
365 // CHECK-LABEL: @test_vzip1_u16(
366 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
367 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
368 uint16x4_t
test_vzip1_u16(uint16x4_t a
, uint16x4_t b
) {
369 return vzip1_u16(a
, b
);
372 // CHECK-LABEL: @test_vzip1q_u16(
373 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
374 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
375 uint16x8_t
test_vzip1q_u16(uint16x8_t a
, uint16x8_t b
) {
376 return vzip1q_u16(a
, b
);
379 // CHECK-LABEL: @test_vzip1_u32(
380 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
381 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
382 uint32x2_t
test_vzip1_u32(uint32x2_t a
, uint32x2_t b
) {
383 return vzip1_u32(a
, b
);
386 // CHECK-LABEL: @test_vzip1q_u32(
387 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
388 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
389 uint32x4_t
test_vzip1q_u32(uint32x4_t a
, uint32x4_t b
) {
390 return vzip1q_u32(a
, b
);
393 // CHECK-LABEL: @test_vzip1q_u64(
394 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
395 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
396 uint64x2_t
test_vzip1q_u64(uint64x2_t a
, uint64x2_t b
) {
397 return vzip1q_u64(a
, b
);
400 // CHECK-LABEL: @test_vzip1_f32(
401 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
402 // CHECK: ret <2 x float> [[SHUFFLE_I]]
403 float32x2_t
test_vzip1_f32(float32x2_t a
, float32x2_t b
) {
404 return vzip1_f32(a
, b
);
407 // CHECK-LABEL: @test_vzip1q_f32(
408 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
409 // CHECK: ret <4 x float> [[SHUFFLE_I]]
410 float32x4_t
test_vzip1q_f32(float32x4_t a
, float32x4_t b
) {
411 return vzip1q_f32(a
, b
);
414 // CHECK-LABEL: @test_vzip1q_f64(
415 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 0, i32 2>
416 // CHECK: ret <2 x double> [[SHUFFLE_I]]
417 float64x2_t
test_vzip1q_f64(float64x2_t a
, float64x2_t b
) {
418 return vzip1q_f64(a
, b
);
421 // CHECK-LABEL: @test_vzip1_p8(
422 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
423 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
424 poly8x8_t
test_vzip1_p8(poly8x8_t a
, poly8x8_t b
) {
425 return vzip1_p8(a
, b
);
428 // CHECK-LABEL: @test_vzip1q_p8(
429 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
430 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
431 poly8x16_t
test_vzip1q_p8(poly8x16_t a
, poly8x16_t b
) {
432 return vzip1q_p8(a
, b
);
435 // CHECK-LABEL: @test_vzip1_p16(
436 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
437 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
438 poly16x4_t
test_vzip1_p16(poly16x4_t a
, poly16x4_t b
) {
439 return vzip1_p16(a
, b
);
442 // CHECK-LABEL: @test_vzip1q_p16(
443 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
444 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
445 poly16x8_t
test_vzip1q_p16(poly16x8_t a
, poly16x8_t b
) {
446 return vzip1q_p16(a
, b
);
449 // CHECK-LABEL: @test_vzip2_s8(
450 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
451 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
452 int8x8_t
test_vzip2_s8(int8x8_t a
, int8x8_t b
) {
453 return vzip2_s8(a
, b
);
456 // CHECK-LABEL: @test_vzip2q_s8(
457 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
458 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
459 int8x16_t
test_vzip2q_s8(int8x16_t a
, int8x16_t b
) {
460 return vzip2q_s8(a
, b
);
463 // CHECK-LABEL: @test_vzip2_s16(
464 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
465 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
466 int16x4_t
test_vzip2_s16(int16x4_t a
, int16x4_t b
) {
467 return vzip2_s16(a
, b
);
470 // CHECK-LABEL: @test_vzip2q_s16(
471 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
472 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
473 int16x8_t
test_vzip2q_s16(int16x8_t a
, int16x8_t b
) {
474 return vzip2q_s16(a
, b
);
477 // CHECK-LABEL: @test_vzip2_s32(
478 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
479 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
480 int32x2_t
test_vzip2_s32(int32x2_t a
, int32x2_t b
) {
481 return vzip2_s32(a
, b
);
484 // CHECK-LABEL: @test_vzip2q_s32(
485 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
486 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
487 int32x4_t
test_vzip2q_s32(int32x4_t a
, int32x4_t b
) {
488 return vzip2q_s32(a
, b
);
491 // CHECK-LABEL: @test_vzip2q_s64(
492 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
493 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
494 int64x2_t
test_vzip2q_s64(int64x2_t a
, int64x2_t b
) {
495 return vzip2q_s64(a
, b
);
498 // CHECK-LABEL: @test_vzip2_u8(
499 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
500 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
501 uint8x8_t
test_vzip2_u8(uint8x8_t a
, uint8x8_t b
) {
502 return vzip2_u8(a
, b
);
505 // CHECK-LABEL: @test_vzip2q_u8(
506 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
507 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
508 uint8x16_t
test_vzip2q_u8(uint8x16_t a
, uint8x16_t b
) {
509 return vzip2q_u8(a
, b
);
512 // CHECK-LABEL: @test_vzip2_u16(
513 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
514 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
515 uint16x4_t
test_vzip2_u16(uint16x4_t a
, uint16x4_t b
) {
516 return vzip2_u16(a
, b
);
519 // CHECK-LABEL: @test_vzip2q_u16(
520 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
521 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
522 uint16x8_t
test_vzip2q_u16(uint16x8_t a
, uint16x8_t b
) {
523 return vzip2q_u16(a
, b
);
526 // CHECK-LABEL: @test_vzip2_u32(
527 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
528 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
529 uint32x2_t
test_vzip2_u32(uint32x2_t a
, uint32x2_t b
) {
530 return vzip2_u32(a
, b
);
533 // CHECK-LABEL: @test_vzip2q_u32(
534 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
535 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
536 uint32x4_t
test_vzip2q_u32(uint32x4_t a
, uint32x4_t b
) {
537 return vzip2q_u32(a
, b
);
540 // CHECK-LABEL: @test_vzip2q_u64(
541 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
542 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
543 uint64x2_t
test_vzip2q_u64(uint64x2_t a
, uint64x2_t b
) {
544 return vzip2q_u64(a
, b
);
547 // CHECK-LABEL: @test_vzip2_f32(
548 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
549 // CHECK: ret <2 x float> [[SHUFFLE_I]]
550 float32x2_t
test_vzip2_f32(float32x2_t a
, float32x2_t b
) {
551 return vzip2_f32(a
, b
);
554 // CHECK-LABEL: @test_vzip2q_f32(
555 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
556 // CHECK: ret <4 x float> [[SHUFFLE_I]]
557 float32x4_t
test_vzip2q_f32(float32x4_t a
, float32x4_t b
) {
558 return vzip2q_f32(a
, b
);
561 // CHECK-LABEL: @test_vzip2q_f64(
562 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 1, i32 3>
563 // CHECK: ret <2 x double> [[SHUFFLE_I]]
564 float64x2_t
test_vzip2q_f64(float64x2_t a
, float64x2_t b
) {
565 return vzip2q_f64(a
, b
);
568 // CHECK-LABEL: @test_vzip2_p8(
569 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
570 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
571 poly8x8_t
test_vzip2_p8(poly8x8_t a
, poly8x8_t b
) {
572 return vzip2_p8(a
, b
);
575 // CHECK-LABEL: @test_vzip2q_p8(
576 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
577 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
578 poly8x16_t
test_vzip2q_p8(poly8x16_t a
, poly8x16_t b
) {
579 return vzip2q_p8(a
, b
);
582 // CHECK-LABEL: @test_vzip2_p16(
583 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
584 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
585 poly16x4_t
test_vzip2_p16(poly16x4_t a
, poly16x4_t b
) {
586 return vzip2_p16(a
, b
);
589 // CHECK-LABEL: @test_vzip2q_p16(
590 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
591 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
592 poly16x8_t
test_vzip2q_p16(poly16x8_t a
, poly16x8_t b
) {
593 return vzip2q_p16(a
, b
);
596 // CHECK-LABEL: @test_vtrn1_s8(
597 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
598 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
599 int8x8_t
test_vtrn1_s8(int8x8_t a
, int8x8_t b
) {
600 return vtrn1_s8(a
, b
);
603 // CHECK-LABEL: @test_vtrn1q_s8(
604 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
605 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
606 int8x16_t
test_vtrn1q_s8(int8x16_t a
, int8x16_t b
) {
607 return vtrn1q_s8(a
, b
);
610 // CHECK-LABEL: @test_vtrn1_s16(
611 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
612 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
613 int16x4_t
test_vtrn1_s16(int16x4_t a
, int16x4_t b
) {
614 return vtrn1_s16(a
, b
);
617 // CHECK-LABEL: @test_vtrn1q_s16(
618 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
619 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
620 int16x8_t
test_vtrn1q_s16(int16x8_t a
, int16x8_t b
) {
621 return vtrn1q_s16(a
, b
);
624 // CHECK-LABEL: @test_vtrn1_s32(
625 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
626 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
627 int32x2_t
test_vtrn1_s32(int32x2_t a
, int32x2_t b
) {
628 return vtrn1_s32(a
, b
);
631 // CHECK-LABEL: @test_vtrn1q_s32(
632 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
633 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
634 int32x4_t
test_vtrn1q_s32(int32x4_t a
, int32x4_t b
) {
635 return vtrn1q_s32(a
, b
);
638 // CHECK-LABEL: @test_vtrn1q_s64(
639 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
640 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
641 int64x2_t
test_vtrn1q_s64(int64x2_t a
, int64x2_t b
) {
642 return vtrn1q_s64(a
, b
);
645 // CHECK-LABEL: @test_vtrn1_u8(
646 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
647 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
648 uint8x8_t
test_vtrn1_u8(uint8x8_t a
, uint8x8_t b
) {
649 return vtrn1_u8(a
, b
);
652 // CHECK-LABEL: @test_vtrn1q_u8(
653 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
654 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
655 uint8x16_t
test_vtrn1q_u8(uint8x16_t a
, uint8x16_t b
) {
656 return vtrn1q_u8(a
, b
);
659 // CHECK-LABEL: @test_vtrn1_u16(
660 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
661 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
662 uint16x4_t
test_vtrn1_u16(uint16x4_t a
, uint16x4_t b
) {
663 return vtrn1_u16(a
, b
);
666 // CHECK-LABEL: @test_vtrn1q_u16(
667 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
668 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
669 uint16x8_t
test_vtrn1q_u16(uint16x8_t a
, uint16x8_t b
) {
670 return vtrn1q_u16(a
, b
);
673 // CHECK-LABEL: @test_vtrn1_u32(
674 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
675 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
676 uint32x2_t
test_vtrn1_u32(uint32x2_t a
, uint32x2_t b
) {
677 return vtrn1_u32(a
, b
);
680 // CHECK-LABEL: @test_vtrn1q_u32(
681 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
682 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
683 uint32x4_t
test_vtrn1q_u32(uint32x4_t a
, uint32x4_t b
) {
684 return vtrn1q_u32(a
, b
);
687 // CHECK-LABEL: @test_vtrn1q_u64(
688 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 0, i32 2>
689 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
690 uint64x2_t
test_vtrn1q_u64(uint64x2_t a
, uint64x2_t b
) {
691 return vtrn1q_u64(a
, b
);
694 // CHECK-LABEL: @test_vtrn1_f32(
695 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
696 // CHECK: ret <2 x float> [[SHUFFLE_I]]
697 float32x2_t
test_vtrn1_f32(float32x2_t a
, float32x2_t b
) {
698 return vtrn1_f32(a
, b
);
701 // CHECK-LABEL: @test_vtrn1q_f32(
702 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
703 // CHECK: ret <4 x float> [[SHUFFLE_I]]
704 float32x4_t
test_vtrn1q_f32(float32x4_t a
, float32x4_t b
) {
705 return vtrn1q_f32(a
, b
);
708 // CHECK-LABEL: @test_vtrn1q_f64(
709 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 0, i32 2>
710 // CHECK: ret <2 x double> [[SHUFFLE_I]]
711 float64x2_t
test_vtrn1q_f64(float64x2_t a
, float64x2_t b
) {
712 return vtrn1q_f64(a
, b
);
715 // CHECK-LABEL: @test_vtrn1_p8(
716 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
717 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
718 poly8x8_t
test_vtrn1_p8(poly8x8_t a
, poly8x8_t b
) {
719 return vtrn1_p8(a
, b
);
722 // CHECK-LABEL: @test_vtrn1q_p8(
723 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
724 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
725 poly8x16_t
test_vtrn1q_p8(poly8x16_t a
, poly8x16_t b
) {
726 return vtrn1q_p8(a
, b
);
729 // CHECK-LABEL: @test_vtrn1_p16(
730 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
731 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
732 poly16x4_t
test_vtrn1_p16(poly16x4_t a
, poly16x4_t b
) {
733 return vtrn1_p16(a
, b
);
736 // CHECK-LABEL: @test_vtrn1q_p16(
737 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
738 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
739 poly16x8_t
test_vtrn1q_p16(poly16x8_t a
, poly16x8_t b
) {
740 return vtrn1q_p16(a
, b
);
743 // CHECK-LABEL: @test_vtrn2_s8(
744 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
745 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
746 int8x8_t
test_vtrn2_s8(int8x8_t a
, int8x8_t b
) {
747 return vtrn2_s8(a
, b
);
750 // CHECK-LABEL: @test_vtrn2q_s8(
751 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
752 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
753 int8x16_t
test_vtrn2q_s8(int8x16_t a
, int8x16_t b
) {
754 return vtrn2q_s8(a
, b
);
757 // CHECK-LABEL: @test_vtrn2_s16(
758 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
759 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
760 int16x4_t
test_vtrn2_s16(int16x4_t a
, int16x4_t b
) {
761 return vtrn2_s16(a
, b
);
764 // CHECK-LABEL: @test_vtrn2q_s16(
765 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
766 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
767 int16x8_t
test_vtrn2q_s16(int16x8_t a
, int16x8_t b
) {
768 return vtrn2q_s16(a
, b
);
771 // CHECK-LABEL: @test_vtrn2_s32(
772 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
773 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
774 int32x2_t
test_vtrn2_s32(int32x2_t a
, int32x2_t b
) {
775 return vtrn2_s32(a
, b
);
778 // CHECK-LABEL: @test_vtrn2q_s32(
779 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
780 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
781 int32x4_t
test_vtrn2q_s32(int32x4_t a
, int32x4_t b
) {
782 return vtrn2q_s32(a
, b
);
785 // CHECK-LABEL: @test_vtrn2q_s64(
786 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
787 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
788 int64x2_t
test_vtrn2q_s64(int64x2_t a
, int64x2_t b
) {
789 return vtrn2q_s64(a
, b
);
792 // CHECK-LABEL: @test_vtrn2_u8(
793 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
794 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
795 uint8x8_t
test_vtrn2_u8(uint8x8_t a
, uint8x8_t b
) {
796 return vtrn2_u8(a
, b
);
799 // CHECK-LABEL: @test_vtrn2q_u8(
800 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
801 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
802 uint8x16_t
test_vtrn2q_u8(uint8x16_t a
, uint8x16_t b
) {
803 return vtrn2q_u8(a
, b
);
806 // CHECK-LABEL: @test_vtrn2_u16(
807 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
808 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
809 uint16x4_t
test_vtrn2_u16(uint16x4_t a
, uint16x4_t b
) {
810 return vtrn2_u16(a
, b
);
813 // CHECK-LABEL: @test_vtrn2q_u16(
814 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
815 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
816 uint16x8_t
test_vtrn2q_u16(uint16x8_t a
, uint16x8_t b
) {
817 return vtrn2q_u16(a
, b
);
820 // CHECK-LABEL: @test_vtrn2_u32(
821 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
822 // CHECK: ret <2 x i32> [[SHUFFLE_I]]
823 uint32x2_t
test_vtrn2_u32(uint32x2_t a
, uint32x2_t b
) {
824 return vtrn2_u32(a
, b
);
827 // CHECK-LABEL: @test_vtrn2q_u32(
828 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
829 // CHECK: ret <4 x i32> [[SHUFFLE_I]]
830 uint32x4_t
test_vtrn2q_u32(uint32x4_t a
, uint32x4_t b
) {
831 return vtrn2q_u32(a
, b
);
834 // CHECK-LABEL: @test_vtrn2q_u64(
835 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x i64> %a, <2 x i64> %b, <2 x i32> <i32 1, i32 3>
836 // CHECK: ret <2 x i64> [[SHUFFLE_I]]
837 uint64x2_t
test_vtrn2q_u64(uint64x2_t a
, uint64x2_t b
) {
838 return vtrn2q_u64(a
, b
);
841 // CHECK-LABEL: @test_vtrn2_f32(
842 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
843 // CHECK: ret <2 x float> [[SHUFFLE_I]]
844 float32x2_t
test_vtrn2_f32(float32x2_t a
, float32x2_t b
) {
845 return vtrn2_f32(a
, b
);
848 // CHECK-LABEL: @test_vtrn2q_f32(
849 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
850 // CHECK: ret <4 x float> [[SHUFFLE_I]]
851 float32x4_t
test_vtrn2q_f32(float32x4_t a
, float32x4_t b
) {
852 return vtrn2q_f32(a
, b
);
855 // CHECK-LABEL: @test_vtrn2q_f64(
856 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <2 x double> %a, <2 x double> %b, <2 x i32> <i32 1, i32 3>
857 // CHECK: ret <2 x double> [[SHUFFLE_I]]
858 float64x2_t
test_vtrn2q_f64(float64x2_t a
, float64x2_t b
) {
859 return vtrn2q_f64(a
, b
);
862 // CHECK-LABEL: @test_vtrn2_p8(
863 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
864 // CHECK: ret <8 x i8> [[SHUFFLE_I]]
865 poly8x8_t
test_vtrn2_p8(poly8x8_t a
, poly8x8_t b
) {
866 return vtrn2_p8(a
, b
);
869 // CHECK-LABEL: @test_vtrn2q_p8(
870 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
871 // CHECK: ret <16 x i8> [[SHUFFLE_I]]
872 poly8x16_t
test_vtrn2q_p8(poly8x16_t a
, poly8x16_t b
) {
873 return vtrn2q_p8(a
, b
);
876 // CHECK-LABEL: @test_vtrn2_p16(
877 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
878 // CHECK: ret <4 x i16> [[SHUFFLE_I]]
879 poly16x4_t
test_vtrn2_p16(poly16x4_t a
, poly16x4_t b
) {
880 return vtrn2_p16(a
, b
);
883 // CHECK-LABEL: @test_vtrn2q_p16(
884 // CHECK: [[SHUFFLE_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
885 // CHECK: ret <8 x i16> [[SHUFFLE_I]]
886 poly16x8_t
test_vtrn2q_p16(poly16x8_t a
, poly16x8_t b
) {
887 return vtrn2q_p16(a
, b
);
890 // CHECK-LABEL: @test_vuzp_s8(
891 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int8x8x2_t, align 8
892 // CHECK: [[RETVAL:%.*]] = alloca %struct.int8x8x2_t, align 8
893 // CHECK: [[VUZP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
894 // CHECK: store <8 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
895 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
896 // CHECK: [[VUZP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
897 // CHECK: store <8 x i8> [[VUZP1_I]], ptr [[TMP2]]
898 // CHECK: [[TMP5:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL_I]], align 8
899 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.int8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
900 // CHECK: [[TMP7:%.*]] = extractvalue %struct.int8x8x2_t [[TMP5]], 0
901 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
902 // CHECK: [[TMP8:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL]], align 8
903 // CHECK: ret %struct.int8x8x2_t [[TMP8]]
904 int8x8x2_t
test_vuzp_s8(int8x8_t a
, int8x8_t b
) {
905 return vuzp_s8(a
, b
);
908 // CHECK-LABEL: @test_vuzp_s16(
909 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int16x4x2_t, align 8
910 // CHECK: [[RETVAL:%.*]] = alloca %struct.int16x4x2_t, align 8
911 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
912 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
913 // CHECK: [[VUZP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
914 // CHECK: store <4 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
915 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
916 // CHECK: [[VUZP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
917 // CHECK: store <4 x i16> [[VUZP1_I]], ptr [[TMP4]]
918 // CHECK: [[TMP7:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL_I]], align 8
919 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
920 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int16x4x2_t [[TMP7]], 0
921 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
922 // CHECK: [[TMP10:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL]], align 8
923 // CHECK: ret %struct.int16x4x2_t [[TMP10]]
924 int16x4x2_t
test_vuzp_s16(int16x4_t a
, int16x4_t b
) {
925 return vuzp_s16(a
, b
);
928 // CHECK-LABEL: @test_vuzp_s32(
929 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int32x2x2_t, align 8
930 // CHECK: [[RETVAL:%.*]] = alloca %struct.int32x2x2_t, align 8
931 // CHECK: [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
932 // CHECK: [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
933 // CHECK: [[VUZP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
934 // CHECK: store <2 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
935 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
936 // CHECK: [[VUZP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
937 // CHECK: store <2 x i32> [[VUZP1_I]], ptr [[TMP4]]
938 // CHECK: [[TMP7:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL_I]], align 8
939 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
940 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int32x2x2_t [[TMP7]], 0
941 // CHECK: store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
942 // CHECK: [[TMP10:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL]], align 8
943 // CHECK: ret %struct.int32x2x2_t [[TMP10]]
944 int32x2x2_t
test_vuzp_s32(int32x2_t a
, int32x2_t b
) {
945 return vuzp_s32(a
, b
);
948 // CHECK-LABEL: @test_vuzp_u8(
949 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint8x8x2_t, align 8
950 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint8x8x2_t, align 8
951 // CHECK: [[VUZP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
952 // CHECK: store <8 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
953 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
954 // CHECK: [[VUZP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
955 // CHECK: store <8 x i8> [[VUZP1_I]], ptr [[TMP2]]
956 // CHECK: [[TMP5:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL_I]], align 8
957 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.uint8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
958 // CHECK: [[TMP7:%.*]] = extractvalue %struct.uint8x8x2_t [[TMP5]], 0
959 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
960 // CHECK: [[TMP8:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL]], align 8
961 // CHECK: ret %struct.uint8x8x2_t [[TMP8]]
962 uint8x8x2_t
test_vuzp_u8(uint8x8_t a
, uint8x8_t b
) {
963 return vuzp_u8(a
, b
);
966 // CHECK-LABEL: @test_vuzp_u16(
967 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint16x4x2_t, align 8
968 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint16x4x2_t, align 8
969 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
970 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
971 // CHECK: [[VUZP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
972 // CHECK: store <4 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
973 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
974 // CHECK: [[VUZP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
975 // CHECK: store <4 x i16> [[VUZP1_I]], ptr [[TMP4]]
976 // CHECK: [[TMP7:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL_I]], align 8
977 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
978 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint16x4x2_t [[TMP7]], 0
979 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
980 // CHECK: [[TMP10:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL]], align 8
981 // CHECK: ret %struct.uint16x4x2_t [[TMP10]]
982 uint16x4x2_t
test_vuzp_u16(uint16x4_t a
, uint16x4_t b
) {
983 return vuzp_u16(a
, b
);
986 // CHECK-LABEL: @test_vuzp_u32(
987 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint32x2x2_t, align 8
988 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint32x2x2_t, align 8
989 // CHECK: [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
990 // CHECK: [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
991 // CHECK: [[VUZP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
992 // CHECK: store <2 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
993 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
994 // CHECK: [[VUZP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
995 // CHECK: store <2 x i32> [[VUZP1_I]], ptr [[TMP4]]
996 // CHECK: [[TMP7:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL_I]], align 8
997 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
998 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint32x2x2_t [[TMP7]], 0
999 // CHECK: store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1000 // CHECK: [[TMP10:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL]], align 8
1001 // CHECK: ret %struct.uint32x2x2_t [[TMP10]]
1002 uint32x2x2_t
test_vuzp_u32(uint32x2_t a
, uint32x2_t b
) {
1003 return vuzp_u32(a
, b
);
1006 // CHECK-LABEL: @test_vuzp_f32(
1007 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.float32x2x2_t, align 8
1008 // CHECK: [[RETVAL:%.*]] = alloca %struct.float32x2x2_t, align 8
1009 // CHECK: [[TMP1:%.*]] = bitcast <2 x float> %a to <8 x i8>
1010 // CHECK: [[TMP2:%.*]] = bitcast <2 x float> %b to <8 x i8>
1011 // CHECK: [[VUZP_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
1012 // CHECK: store <2 x float> [[VUZP_I]], ptr [[RETVAL_I]]
1013 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x float>, ptr [[RETVAL_I]], i32 1
1014 // CHECK: [[VUZP1_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
1015 // CHECK: store <2 x float> [[VUZP1_I]], ptr [[TMP4]]
1016 // CHECK: [[TMP7:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL_I]], align 8
1017 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.float32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1018 // CHECK: [[TMP9:%.*]] = extractvalue %struct.float32x2x2_t [[TMP7]], 0
1019 // CHECK: store [2 x <2 x float>] [[TMP9]], ptr [[TMP8]], align 8
1020 // CHECK: [[TMP10:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL]], align 8
1021 // CHECK: ret %struct.float32x2x2_t [[TMP10]]
1022 float32x2x2_t
test_vuzp_f32(float32x2_t a
, float32x2_t b
) {
1023 return vuzp_f32(a
, b
);
1026 // CHECK-LABEL: @test_vuzp_p8(
1027 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly8x8x2_t, align 8
1028 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly8x8x2_t, align 8
1029 // CHECK: [[VUZP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1030 // CHECK: store <8 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1031 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1032 // CHECK: [[VUZP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1033 // CHECK: store <8 x i8> [[VUZP1_I]], ptr [[TMP2]]
1034 // CHECK: [[TMP5:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL_I]], align 8
1035 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.poly8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1036 // CHECK: [[TMP7:%.*]] = extractvalue %struct.poly8x8x2_t [[TMP5]], 0
1037 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1038 // CHECK: [[TMP8:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL]], align 8
1039 // CHECK: ret %struct.poly8x8x2_t [[TMP8]]
1040 poly8x8x2_t
test_vuzp_p8(poly8x8_t a
, poly8x8_t b
) {
1041 return vuzp_p8(a
, b
);
1044 // CHECK-LABEL: @test_vuzp_p16(
1045 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly16x4x2_t, align 8
1046 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly16x4x2_t, align 8
1047 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1048 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1049 // CHECK: [[VUZP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1050 // CHECK: store <4 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1051 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1052 // CHECK: [[VUZP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1053 // CHECK: store <4 x i16> [[VUZP1_I]], ptr [[TMP4]]
1054 // CHECK: [[TMP7:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL_I]], align 8
1055 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.poly16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1056 // CHECK: [[TMP9:%.*]] = extractvalue %struct.poly16x4x2_t [[TMP7]], 0
1057 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1058 // CHECK: [[TMP10:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL]], align 8
1059 // CHECK: ret %struct.poly16x4x2_t [[TMP10]]
1060 poly16x4x2_t
test_vuzp_p16(poly16x4_t a
, poly16x4_t b
) {
1061 return vuzp_p16(a
, b
);
1064 // CHECK-LABEL: @test_vuzpq_s8(
1065 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int8x16x2_t, align 16
1066 // CHECK: [[RETVAL:%.*]] = alloca %struct.int8x16x2_t, align 16
1067 // CHECK: [[VUZP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
1068 // CHECK: store <16 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1069 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1070 // CHECK: [[VUZP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
1071 // CHECK: store <16 x i8> [[VUZP1_I]], ptr [[TMP2]]
1072 // CHECK: [[TMP5:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL_I]], align 16
1073 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.int8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1074 // CHECK: [[TMP7:%.*]] = extractvalue %struct.int8x16x2_t [[TMP5]], 0
1075 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1076 // CHECK: [[TMP8:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL]], align 16
1077 // CHECK: ret %struct.int8x16x2_t [[TMP8]]
1078 int8x16x2_t
test_vuzpq_s8(int8x16_t a
, int8x16_t b
) {
1079 return vuzpq_s8(a
, b
);
1082 // CHECK-LABEL: @test_vuzpq_s16(
1083 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int16x8x2_t, align 16
1084 // CHECK: [[RETVAL:%.*]] = alloca %struct.int16x8x2_t, align 16
1085 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1086 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1087 // CHECK: [[VUZP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1088 // CHECK: store <8 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1089 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1090 // CHECK: [[VUZP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1091 // CHECK: store <8 x i16> [[VUZP1_I]], ptr [[TMP4]]
1092 // CHECK: [[TMP7:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL_I]], align 16
1093 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1094 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int16x8x2_t [[TMP7]], 0
1095 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1096 // CHECK: [[TMP10:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL]], align 16
1097 // CHECK: ret %struct.int16x8x2_t [[TMP10]]
1098 int16x8x2_t
test_vuzpq_s16(int16x8_t a
, int16x8_t b
) {
1099 return vuzpq_s16(a
, b
);
1102 // CHECK-LABEL: @test_vuzpq_s32(
1103 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int32x4x2_t, align 16
1104 // CHECK: [[RETVAL:%.*]] = alloca %struct.int32x4x2_t, align 16
1105 // CHECK: [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1106 // CHECK: [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1107 // CHECK: [[VUZP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1108 // CHECK: store <4 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
1109 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1110 // CHECK: [[VUZP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1111 // CHECK: store <4 x i32> [[VUZP1_I]], ptr [[TMP4]]
1112 // CHECK: [[TMP7:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL_I]], align 16
1113 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1114 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int32x4x2_t [[TMP7]], 0
1115 // CHECK: store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1116 // CHECK: [[TMP10:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL]], align 16
1117 // CHECK: ret %struct.int32x4x2_t [[TMP10]]
1118 int32x4x2_t
test_vuzpq_s32(int32x4_t a
, int32x4_t b
) {
1119 return vuzpq_s32(a
, b
);
1122 // CHECK-LABEL: @test_vuzpq_u8(
1123 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint8x16x2_t, align 16
1124 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint8x16x2_t, align 16
1125 // CHECK: [[VUZP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
1126 // CHECK: store <16 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1127 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1128 // CHECK: [[VUZP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
1129 // CHECK: store <16 x i8> [[VUZP1_I]], ptr [[TMP2]]
1130 // CHECK: [[TMP5:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL_I]], align 16
1131 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.uint8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1132 // CHECK: [[TMP7:%.*]] = extractvalue %struct.uint8x16x2_t [[TMP5]], 0
1133 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1134 // CHECK: [[TMP8:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL]], align 16
1135 // CHECK: ret %struct.uint8x16x2_t [[TMP8]]
1136 uint8x16x2_t
test_vuzpq_u8(uint8x16_t a
, uint8x16_t b
) {
1137 return vuzpq_u8(a
, b
);
1140 // CHECK-LABEL: @test_vuzpq_u16(
1141 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint16x8x2_t, align 16
1142 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint16x8x2_t, align 16
1143 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1144 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1145 // CHECK: [[VUZP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1146 // CHECK: store <8 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1147 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1148 // CHECK: [[VUZP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1149 // CHECK: store <8 x i16> [[VUZP1_I]], ptr [[TMP4]]
1150 // CHECK: [[TMP7:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL_I]], align 16
1151 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1152 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint16x8x2_t [[TMP7]], 0
1153 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1154 // CHECK: [[TMP10:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL]], align 16
1155 // CHECK: ret %struct.uint16x8x2_t [[TMP10]]
1156 uint16x8x2_t
test_vuzpq_u16(uint16x8_t a
, uint16x8_t b
) {
1157 return vuzpq_u16(a
, b
);
1160 // CHECK-LABEL: @test_vuzpq_u32(
1161 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint32x4x2_t, align 16
1162 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint32x4x2_t, align 16
1163 // CHECK: [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1164 // CHECK: [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1165 // CHECK: [[VUZP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1166 // CHECK: store <4 x i32> [[VUZP_I]], ptr [[RETVAL_I]]
1167 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1168 // CHECK: [[VUZP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1169 // CHECK: store <4 x i32> [[VUZP1_I]], ptr [[TMP4]]
1170 // CHECK: [[TMP7:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL_I]], align 16
1171 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1172 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint32x4x2_t [[TMP7]], 0
1173 // CHECK: store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1174 // CHECK: [[TMP10:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL]], align 16
1175 // CHECK: ret %struct.uint32x4x2_t [[TMP10]]
1176 uint32x4x2_t
test_vuzpq_u32(uint32x4_t a
, uint32x4_t b
) {
1177 return vuzpq_u32(a
, b
);
1180 // CHECK-LABEL: @test_vuzpq_f32(
1181 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.float32x4x2_t, align 16
1182 // CHECK: [[RETVAL:%.*]] = alloca %struct.float32x4x2_t, align 16
1183 // CHECK: [[TMP1:%.*]] = bitcast <4 x float> %a to <16 x i8>
1184 // CHECK: [[TMP2:%.*]] = bitcast <4 x float> %b to <16 x i8>
1185 // CHECK: [[VUZP_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
1186 // CHECK: store <4 x float> [[VUZP_I]], ptr [[RETVAL_I]]
1187 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x float>, ptr [[RETVAL_I]], i32 1
1188 // CHECK: [[VUZP1_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
1189 // CHECK: store <4 x float> [[VUZP1_I]], ptr [[TMP4]]
1190 // CHECK: [[TMP7:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL_I]], align 16
1191 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.float32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1192 // CHECK: [[TMP9:%.*]] = extractvalue %struct.float32x4x2_t [[TMP7]], 0
1193 // CHECK: store [2 x <4 x float>] [[TMP9]], ptr [[TMP8]], align 16
1194 // CHECK: [[TMP10:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL]], align 16
1195 // CHECK: ret %struct.float32x4x2_t [[TMP10]]
1196 float32x4x2_t
test_vuzpq_f32(float32x4_t a
, float32x4_t b
) {
1197 return vuzpq_f32(a
, b
);
1200 // CHECK-LABEL: @test_vuzpq_p8(
1201 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly8x16x2_t, align 16
1202 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly8x16x2_t, align 16
1203 // CHECK: [[VUZP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
1204 // CHECK: store <16 x i8> [[VUZP_I]], ptr [[RETVAL_I]]
1205 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1206 // CHECK: [[VUZP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
1207 // CHECK: store <16 x i8> [[VUZP1_I]], ptr [[TMP2]]
1208 // CHECK: [[TMP5:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL_I]], align 16
1209 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.poly8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1210 // CHECK: [[TMP7:%.*]] = extractvalue %struct.poly8x16x2_t [[TMP5]], 0
1211 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1212 // CHECK: [[TMP8:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL]], align 16
1213 // CHECK: ret %struct.poly8x16x2_t [[TMP8]]
1214 poly8x16x2_t
test_vuzpq_p8(poly8x16_t a
, poly8x16_t b
) {
1215 return vuzpq_p8(a
, b
);
1218 // CHECK-LABEL: @test_vuzpq_p16(
1219 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly16x8x2_t, align 16
1220 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly16x8x2_t, align 16
1221 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1222 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1223 // CHECK: [[VUZP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
1224 // CHECK: store <8 x i16> [[VUZP_I]], ptr [[RETVAL_I]]
1225 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1226 // CHECK: [[VUZP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
1227 // CHECK: store <8 x i16> [[VUZP1_I]], ptr [[TMP4]]
1228 // CHECK: [[TMP7:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL_I]], align 16
1229 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.poly16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1230 // CHECK: [[TMP9:%.*]] = extractvalue %struct.poly16x8x2_t [[TMP7]], 0
1231 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1232 // CHECK: [[TMP10:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL]], align 16
1233 // CHECK: ret %struct.poly16x8x2_t [[TMP10]]
1234 poly16x8x2_t
test_vuzpq_p16(poly16x8_t a
, poly16x8_t b
) {
1235 return vuzpq_p16(a
, b
);
1238 // CHECK-LABEL: @test_vzip_s8(
1239 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int8x8x2_t, align 8
1240 // CHECK: [[RETVAL:%.*]] = alloca %struct.int8x8x2_t, align 8
1241 // CHECK: [[VZIP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1242 // CHECK: store <8 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1243 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1244 // CHECK: [[VZIP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1245 // CHECK: store <8 x i8> [[VZIP1_I]], ptr [[TMP2]]
1246 // CHECK: [[TMP5:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL_I]], align 8
1247 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.int8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1248 // CHECK: [[TMP7:%.*]] = extractvalue %struct.int8x8x2_t [[TMP5]], 0
1249 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1250 // CHECK: [[TMP8:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL]], align 8
1251 // CHECK: ret %struct.int8x8x2_t [[TMP8]]
1252 int8x8x2_t
test_vzip_s8(int8x8_t a
, int8x8_t b
) {
1253 return vzip_s8(a
, b
);
1256 // CHECK-LABEL: @test_vzip_s16(
1257 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int16x4x2_t, align 8
1258 // CHECK: [[RETVAL:%.*]] = alloca %struct.int16x4x2_t, align 8
1259 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1260 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1261 // CHECK: [[VZIP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1262 // CHECK: store <4 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1263 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1264 // CHECK: [[VZIP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1265 // CHECK: store <4 x i16> [[VZIP1_I]], ptr [[TMP4]]
1266 // CHECK: [[TMP7:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL_I]], align 8
1267 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1268 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int16x4x2_t [[TMP7]], 0
1269 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1270 // CHECK: [[TMP10:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL]], align 8
1271 // CHECK: ret %struct.int16x4x2_t [[TMP10]]
1272 int16x4x2_t
test_vzip_s16(int16x4_t a
, int16x4_t b
) {
1273 return vzip_s16(a
, b
);
1276 // CHECK-LABEL: @test_vzip_s32(
1277 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int32x2x2_t, align 8
1278 // CHECK: [[RETVAL:%.*]] = alloca %struct.int32x2x2_t, align 8
1279 // CHECK: [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1280 // CHECK: [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1281 // CHECK: [[VZIP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1282 // CHECK: store <2 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1283 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1284 // CHECK: [[VZIP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1285 // CHECK: store <2 x i32> [[VZIP1_I]], ptr [[TMP4]]
1286 // CHECK: [[TMP7:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL_I]], align 8
1287 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1288 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int32x2x2_t [[TMP7]], 0
1289 // CHECK: store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1290 // CHECK: [[TMP10:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL]], align 8
1291 // CHECK: ret %struct.int32x2x2_t [[TMP10]]
1292 int32x2x2_t
test_vzip_s32(int32x2_t a
, int32x2_t b
) {
1293 return vzip_s32(a
, b
);
1296 // CHECK-LABEL: @test_vzip_u8(
1297 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint8x8x2_t, align 8
1298 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint8x8x2_t, align 8
1299 // CHECK: [[VZIP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1300 // CHECK: store <8 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1301 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1302 // CHECK: [[VZIP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1303 // CHECK: store <8 x i8> [[VZIP1_I]], ptr [[TMP2]]
1304 // CHECK: [[TMP5:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL_I]], align 8
1305 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.uint8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1306 // CHECK: [[TMP7:%.*]] = extractvalue %struct.uint8x8x2_t [[TMP5]], 0
1307 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1308 // CHECK: [[TMP8:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL]], align 8
1309 // CHECK: ret %struct.uint8x8x2_t [[TMP8]]
1310 uint8x8x2_t
test_vzip_u8(uint8x8_t a
, uint8x8_t b
) {
1311 return vzip_u8(a
, b
);
1314 // CHECK-LABEL: @test_vzip_u16(
1315 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint16x4x2_t, align 8
1316 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint16x4x2_t, align 8
1317 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1318 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1319 // CHECK: [[VZIP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1320 // CHECK: store <4 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1321 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1322 // CHECK: [[VZIP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1323 // CHECK: store <4 x i16> [[VZIP1_I]], ptr [[TMP4]]
1324 // CHECK: [[TMP7:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL_I]], align 8
1325 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1326 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint16x4x2_t [[TMP7]], 0
1327 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1328 // CHECK: [[TMP10:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL]], align 8
1329 // CHECK: ret %struct.uint16x4x2_t [[TMP10]]
1330 uint16x4x2_t
test_vzip_u16(uint16x4_t a
, uint16x4_t b
) {
1331 return vzip_u16(a
, b
);
1334 // CHECK-LABEL: @test_vzip_u32(
1335 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint32x2x2_t, align 8
1336 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint32x2x2_t, align 8
1337 // CHECK: [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1338 // CHECK: [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1339 // CHECK: [[VZIP_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1340 // CHECK: store <2 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1341 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1342 // CHECK: [[VZIP1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1343 // CHECK: store <2 x i32> [[VZIP1_I]], ptr [[TMP4]]
1344 // CHECK: [[TMP7:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL_I]], align 8
1345 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1346 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint32x2x2_t [[TMP7]], 0
1347 // CHECK: store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1348 // CHECK: [[TMP10:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL]], align 8
1349 // CHECK: ret %struct.uint32x2x2_t [[TMP10]]
1350 uint32x2x2_t
test_vzip_u32(uint32x2_t a
, uint32x2_t b
) {
1351 return vzip_u32(a
, b
);
1354 // CHECK-LABEL: @test_vzip_f32(
1355 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.float32x2x2_t, align 8
1356 // CHECK: [[RETVAL:%.*]] = alloca %struct.float32x2x2_t, align 8
1357 // CHECK: [[TMP1:%.*]] = bitcast <2 x float> %a to <8 x i8>
1358 // CHECK: [[TMP2:%.*]] = bitcast <2 x float> %b to <8 x i8>
1359 // CHECK: [[VZIP_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
1360 // CHECK: store <2 x float> [[VZIP_I]], ptr [[RETVAL_I]]
1361 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x float>, ptr [[RETVAL_I]], i32 1
1362 // CHECK: [[VZIP1_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
1363 // CHECK: store <2 x float> [[VZIP1_I]], ptr [[TMP4]]
1364 // CHECK: [[TMP7:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL_I]], align 8
1365 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.float32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1366 // CHECK: [[TMP9:%.*]] = extractvalue %struct.float32x2x2_t [[TMP7]], 0
1367 // CHECK: store [2 x <2 x float>] [[TMP9]], ptr [[TMP8]], align 8
1368 // CHECK: [[TMP10:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL]], align 8
1369 // CHECK: ret %struct.float32x2x2_t [[TMP10]]
1370 float32x2x2_t
test_vzip_f32(float32x2_t a
, float32x2_t b
) {
1371 return vzip_f32(a
, b
);
1374 // CHECK-LABEL: @test_vzip_p8(
1375 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly8x8x2_t, align 8
1376 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly8x8x2_t, align 8
1377 // CHECK: [[VZIP_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1378 // CHECK: store <8 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1379 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1380 // CHECK: [[VZIP1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1381 // CHECK: store <8 x i8> [[VZIP1_I]], ptr [[TMP2]]
1382 // CHECK: [[TMP5:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL_I]], align 8
1383 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.poly8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1384 // CHECK: [[TMP7:%.*]] = extractvalue %struct.poly8x8x2_t [[TMP5]], 0
1385 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1386 // CHECK: [[TMP8:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL]], align 8
1387 // CHECK: ret %struct.poly8x8x2_t [[TMP8]]
1388 poly8x8x2_t
test_vzip_p8(poly8x8_t a
, poly8x8_t b
) {
1389 return vzip_p8(a
, b
);
1392 // CHECK-LABEL: @test_vzip_p16(
1393 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly16x4x2_t, align 8
1394 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly16x4x2_t, align 8
1395 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1396 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1397 // CHECK: [[VZIP_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1398 // CHECK: store <4 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1399 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1400 // CHECK: [[VZIP1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1401 // CHECK: store <4 x i16> [[VZIP1_I]], ptr [[TMP4]]
1402 // CHECK: [[TMP7:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL_I]], align 8
1403 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.poly16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1404 // CHECK: [[TMP9:%.*]] = extractvalue %struct.poly16x4x2_t [[TMP7]], 0
1405 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1406 // CHECK: [[TMP10:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL]], align 8
1407 // CHECK: ret %struct.poly16x4x2_t [[TMP10]]
1408 poly16x4x2_t
test_vzip_p16(poly16x4_t a
, poly16x4_t b
) {
1409 return vzip_p16(a
, b
);
1412 // CHECK-LABEL: @test_vzipq_s8(
1413 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int8x16x2_t, align 16
1414 // CHECK: [[RETVAL:%.*]] = alloca %struct.int8x16x2_t, align 16
1415 // CHECK: [[VZIP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1416 // CHECK: store <16 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1417 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1418 // CHECK: [[VZIP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1419 // CHECK: store <16 x i8> [[VZIP1_I]], ptr [[TMP2]]
1420 // CHECK: [[TMP5:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL_I]], align 16
1421 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.int8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1422 // CHECK: [[TMP7:%.*]] = extractvalue %struct.int8x16x2_t [[TMP5]], 0
1423 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1424 // CHECK: [[TMP8:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL]], align 16
1425 // CHECK: ret %struct.int8x16x2_t [[TMP8]]
1426 int8x16x2_t
test_vzipq_s8(int8x16_t a
, int8x16_t b
) {
1427 return vzipq_s8(a
, b
);
1430 // CHECK-LABEL: @test_vzipq_s16(
1431 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int16x8x2_t, align 16
1432 // CHECK: [[RETVAL:%.*]] = alloca %struct.int16x8x2_t, align 16
1433 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1434 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1435 // CHECK: [[VZIP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1436 // CHECK: store <8 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1437 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1438 // CHECK: [[VZIP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1439 // CHECK: store <8 x i16> [[VZIP1_I]], ptr [[TMP4]]
1440 // CHECK: [[TMP7:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL_I]], align 16
1441 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1442 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int16x8x2_t [[TMP7]], 0
1443 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1444 // CHECK: [[TMP10:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL]], align 16
1445 // CHECK: ret %struct.int16x8x2_t [[TMP10]]
1446 int16x8x2_t
test_vzipq_s16(int16x8_t a
, int16x8_t b
) {
1447 return vzipq_s16(a
, b
);
1450 // CHECK-LABEL: @test_vzipq_s32(
1451 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int32x4x2_t, align 16
1452 // CHECK: [[RETVAL:%.*]] = alloca %struct.int32x4x2_t, align 16
1453 // CHECK: [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1454 // CHECK: [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1455 // CHECK: [[VZIP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1456 // CHECK: store <4 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1457 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1458 // CHECK: [[VZIP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1459 // CHECK: store <4 x i32> [[VZIP1_I]], ptr [[TMP4]]
1460 // CHECK: [[TMP7:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL_I]], align 16
1461 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1462 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int32x4x2_t [[TMP7]], 0
1463 // CHECK: store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1464 // CHECK: [[TMP10:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL]], align 16
1465 // CHECK: ret %struct.int32x4x2_t [[TMP10]]
1466 int32x4x2_t
test_vzipq_s32(int32x4_t a
, int32x4_t b
) {
1467 return vzipq_s32(a
, b
);
1470 // CHECK-LABEL: @test_vzipq_u8(
1471 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint8x16x2_t, align 16
1472 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint8x16x2_t, align 16
1473 // CHECK: [[VZIP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1474 // CHECK: store <16 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1475 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1476 // CHECK: [[VZIP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1477 // CHECK: store <16 x i8> [[VZIP1_I]], ptr [[TMP2]]
1478 // CHECK: [[TMP5:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL_I]], align 16
1479 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.uint8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1480 // CHECK: [[TMP7:%.*]] = extractvalue %struct.uint8x16x2_t [[TMP5]], 0
1481 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1482 // CHECK: [[TMP8:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL]], align 16
1483 // CHECK: ret %struct.uint8x16x2_t [[TMP8]]
1484 uint8x16x2_t
test_vzipq_u8(uint8x16_t a
, uint8x16_t b
) {
1485 return vzipq_u8(a
, b
);
1488 // CHECK-LABEL: @test_vzipq_u16(
1489 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint16x8x2_t, align 16
1490 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint16x8x2_t, align 16
1491 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1492 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1493 // CHECK: [[VZIP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1494 // CHECK: store <8 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1495 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1496 // CHECK: [[VZIP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1497 // CHECK: store <8 x i16> [[VZIP1_I]], ptr [[TMP4]]
1498 // CHECK: [[TMP7:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL_I]], align 16
1499 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1500 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint16x8x2_t [[TMP7]], 0
1501 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1502 // CHECK: [[TMP10:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL]], align 16
1503 // CHECK: ret %struct.uint16x8x2_t [[TMP10]]
1504 uint16x8x2_t
test_vzipq_u16(uint16x8_t a
, uint16x8_t b
) {
1505 return vzipq_u16(a
, b
);
1508 // CHECK-LABEL: @test_vzipq_u32(
1509 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint32x4x2_t, align 16
1510 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint32x4x2_t, align 16
1511 // CHECK: [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1512 // CHECK: [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1513 // CHECK: [[VZIP_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1514 // CHECK: store <4 x i32> [[VZIP_I]], ptr [[RETVAL_I]]
1515 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1516 // CHECK: [[VZIP1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1517 // CHECK: store <4 x i32> [[VZIP1_I]], ptr [[TMP4]]
1518 // CHECK: [[TMP7:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL_I]], align 16
1519 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1520 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint32x4x2_t [[TMP7]], 0
1521 // CHECK: store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1522 // CHECK: [[TMP10:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL]], align 16
1523 // CHECK: ret %struct.uint32x4x2_t [[TMP10]]
1524 uint32x4x2_t
test_vzipq_u32(uint32x4_t a
, uint32x4_t b
) {
1525 return vzipq_u32(a
, b
);
1528 // CHECK-LABEL: @test_vzipq_f32(
1529 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.float32x4x2_t, align 16
1530 // CHECK: [[RETVAL:%.*]] = alloca %struct.float32x4x2_t, align 16
1531 // CHECK: [[TMP1:%.*]] = bitcast <4 x float> %a to <16 x i8>
1532 // CHECK: [[TMP2:%.*]] = bitcast <4 x float> %b to <16 x i8>
1533 // CHECK: [[VZIP_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1534 // CHECK: store <4 x float> [[VZIP_I]], ptr [[RETVAL_I]]
1535 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x float>, ptr [[RETVAL_I]], i32 1
1536 // CHECK: [[VZIP1_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1537 // CHECK: store <4 x float> [[VZIP1_I]], ptr [[TMP4]]
1538 // CHECK: [[TMP7:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL_I]], align 16
1539 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.float32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1540 // CHECK: [[TMP9:%.*]] = extractvalue %struct.float32x4x2_t [[TMP7]], 0
1541 // CHECK: store [2 x <4 x float>] [[TMP9]], ptr [[TMP8]], align 16
1542 // CHECK: [[TMP10:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL]], align 16
1543 // CHECK: ret %struct.float32x4x2_t [[TMP10]]
1544 float32x4x2_t
test_vzipq_f32(float32x4_t a
, float32x4_t b
) {
1545 return vzipq_f32(a
, b
);
1548 // CHECK-LABEL: @test_vzipq_p8(
1549 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly8x16x2_t, align 16
1550 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly8x16x2_t, align 16
1551 // CHECK: [[VZIP_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
1552 // CHECK: store <16 x i8> [[VZIP_I]], ptr [[RETVAL_I]]
1553 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1554 // CHECK: [[VZIP1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1555 // CHECK: store <16 x i8> [[VZIP1_I]], ptr [[TMP2]]
1556 // CHECK: [[TMP5:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL_I]], align 16
1557 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.poly8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1558 // CHECK: [[TMP7:%.*]] = extractvalue %struct.poly8x16x2_t [[TMP5]], 0
1559 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1560 // CHECK: [[TMP8:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL]], align 16
1561 // CHECK: ret %struct.poly8x16x2_t [[TMP8]]
1562 poly8x16x2_t
test_vzipq_p8(poly8x16_t a
, poly8x16_t b
) {
1563 return vzipq_p8(a
, b
);
1566 // CHECK-LABEL: @test_vzipq_p16(
1567 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly16x8x2_t, align 16
1568 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly16x8x2_t, align 16
1569 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1570 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1571 // CHECK: [[VZIP_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
1572 // CHECK: store <8 x i16> [[VZIP_I]], ptr [[RETVAL_I]]
1573 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1574 // CHECK: [[VZIP1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
1575 // CHECK: store <8 x i16> [[VZIP1_I]], ptr [[TMP4]]
1576 // CHECK: [[TMP7:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL_I]], align 16
1577 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.poly16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1578 // CHECK: [[TMP9:%.*]] = extractvalue %struct.poly16x8x2_t [[TMP7]], 0
1579 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1580 // CHECK: [[TMP10:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL]], align 16
1581 // CHECK: ret %struct.poly16x8x2_t [[TMP10]]
1582 poly16x8x2_t
test_vzipq_p16(poly16x8_t a
, poly16x8_t b
) {
1583 return vzipq_p16(a
, b
);
1586 // CHECK-LABEL: @test_vtrn_s8(
1587 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int8x8x2_t, align 8
1588 // CHECK: [[RETVAL:%.*]] = alloca %struct.int8x8x2_t, align 8
1589 // CHECK: [[VTRN_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1590 // CHECK: store <8 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1591 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1592 // CHECK: [[VTRN1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1593 // CHECK: store <8 x i8> [[VTRN1_I]], ptr [[TMP2]]
1594 // CHECK: [[TMP5:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL_I]], align 8
1595 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.int8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1596 // CHECK: [[TMP7:%.*]] = extractvalue %struct.int8x8x2_t [[TMP5]], 0
1597 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1598 // CHECK: [[TMP8:%.*]] = load %struct.int8x8x2_t, ptr [[RETVAL]], align 8
1599 // CHECK: ret %struct.int8x8x2_t [[TMP8]]
1600 int8x8x2_t
test_vtrn_s8(int8x8_t a
, int8x8_t b
) {
1601 return vtrn_s8(a
, b
);
1604 // CHECK-LABEL: @test_vtrn_s16(
1605 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int16x4x2_t, align 8
1606 // CHECK: [[RETVAL:%.*]] = alloca %struct.int16x4x2_t, align 8
1607 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1608 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1609 // CHECK: [[VTRN_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1610 // CHECK: store <4 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1611 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1612 // CHECK: [[VTRN1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1613 // CHECK: store <4 x i16> [[VTRN1_I]], ptr [[TMP4]]
1614 // CHECK: [[TMP7:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL_I]], align 8
1615 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1616 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int16x4x2_t [[TMP7]], 0
1617 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1618 // CHECK: [[TMP10:%.*]] = load %struct.int16x4x2_t, ptr [[RETVAL]], align 8
1619 // CHECK: ret %struct.int16x4x2_t [[TMP10]]
1620 int16x4x2_t
test_vtrn_s16(int16x4_t a
, int16x4_t b
) {
1621 return vtrn_s16(a
, b
);
1624 // CHECK-LABEL: @test_vtrn_s32(
1625 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int32x2x2_t, align 8
1626 // CHECK: [[RETVAL:%.*]] = alloca %struct.int32x2x2_t, align 8
1627 // CHECK: [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1628 // CHECK: [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1629 // CHECK: [[VTRN_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1630 // CHECK: store <2 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1631 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1632 // CHECK: [[VTRN1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1633 // CHECK: store <2 x i32> [[VTRN1_I]], ptr [[TMP4]]
1634 // CHECK: [[TMP7:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL_I]], align 8
1635 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1636 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int32x2x2_t [[TMP7]], 0
1637 // CHECK: store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1638 // CHECK: [[TMP10:%.*]] = load %struct.int32x2x2_t, ptr [[RETVAL]], align 8
1639 // CHECK: ret %struct.int32x2x2_t [[TMP10]]
1640 int32x2x2_t
test_vtrn_s32(int32x2_t a
, int32x2_t b
) {
1641 return vtrn_s32(a
, b
);
1644 // CHECK-LABEL: @test_vtrn_u8(
1645 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint8x8x2_t, align 8
1646 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint8x8x2_t, align 8
1647 // CHECK: [[VTRN_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1648 // CHECK: store <8 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1649 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1650 // CHECK: [[VTRN1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1651 // CHECK: store <8 x i8> [[VTRN1_I]], ptr [[TMP2]]
1652 // CHECK: [[TMP5:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL_I]], align 8
1653 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.uint8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1654 // CHECK: [[TMP7:%.*]] = extractvalue %struct.uint8x8x2_t [[TMP5]], 0
1655 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1656 // CHECK: [[TMP8:%.*]] = load %struct.uint8x8x2_t, ptr [[RETVAL]], align 8
1657 // CHECK: ret %struct.uint8x8x2_t [[TMP8]]
1658 uint8x8x2_t
test_vtrn_u8(uint8x8_t a
, uint8x8_t b
) {
1659 return vtrn_u8(a
, b
);
1662 // CHECK-LABEL: @test_vtrn_u16(
1663 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint16x4x2_t, align 8
1664 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint16x4x2_t, align 8
1665 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1666 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1667 // CHECK: [[VTRN_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1668 // CHECK: store <4 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1669 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1670 // CHECK: [[VTRN1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1671 // CHECK: store <4 x i16> [[VTRN1_I]], ptr [[TMP4]]
1672 // CHECK: [[TMP7:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL_I]], align 8
1673 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1674 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint16x4x2_t [[TMP7]], 0
1675 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1676 // CHECK: [[TMP10:%.*]] = load %struct.uint16x4x2_t, ptr [[RETVAL]], align 8
1677 // CHECK: ret %struct.uint16x4x2_t [[TMP10]]
1678 uint16x4x2_t
test_vtrn_u16(uint16x4_t a
, uint16x4_t b
) {
1679 return vtrn_u16(a
, b
);
1682 // CHECK-LABEL: @test_vtrn_u32(
1683 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint32x2x2_t, align 8
1684 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint32x2x2_t, align 8
1685 // CHECK: [[TMP1:%.*]] = bitcast <2 x i32> %a to <8 x i8>
1686 // CHECK: [[TMP2:%.*]] = bitcast <2 x i32> %b to <8 x i8>
1687 // CHECK: [[VTRN_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 0, i32 2>
1688 // CHECK: store <2 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1689 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x i32>, ptr [[RETVAL_I]], i32 1
1690 // CHECK: [[VTRN1_I:%.*]] = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32 1, i32 3>
1691 // CHECK: store <2 x i32> [[VTRN1_I]], ptr [[TMP4]]
1692 // CHECK: [[TMP7:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL_I]], align 8
1693 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1694 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint32x2x2_t [[TMP7]], 0
1695 // CHECK: store [2 x <2 x i32>] [[TMP9]], ptr [[TMP8]], align 8
1696 // CHECK: [[TMP10:%.*]] = load %struct.uint32x2x2_t, ptr [[RETVAL]], align 8
1697 // CHECK: ret %struct.uint32x2x2_t [[TMP10]]
1698 uint32x2x2_t
test_vtrn_u32(uint32x2_t a
, uint32x2_t b
) {
1699 return vtrn_u32(a
, b
);
1702 // CHECK-LABEL: @test_vtrn_f32(
1703 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.float32x2x2_t, align 8
1704 // CHECK: [[RETVAL:%.*]] = alloca %struct.float32x2x2_t, align 8
1705 // CHECK: [[TMP1:%.*]] = bitcast <2 x float> %a to <8 x i8>
1706 // CHECK: [[TMP2:%.*]] = bitcast <2 x float> %b to <8 x i8>
1707 // CHECK: [[VTRN_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 0, i32 2>
1708 // CHECK: store <2 x float> [[VTRN_I]], ptr [[RETVAL_I]]
1709 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <2 x float>, ptr [[RETVAL_I]], i32 1
1710 // CHECK: [[VTRN1_I:%.*]] = shufflevector <2 x float> %a, <2 x float> %b, <2 x i32> <i32 1, i32 3>
1711 // CHECK: store <2 x float> [[VTRN1_I]], ptr [[TMP4]]
1712 // CHECK: [[TMP7:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL_I]], align 8
1713 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.float32x2x2_t, ptr [[RETVAL]], i32 0, i32 0
1714 // CHECK: [[TMP9:%.*]] = extractvalue %struct.float32x2x2_t [[TMP7]], 0
1715 // CHECK: store [2 x <2 x float>] [[TMP9]], ptr [[TMP8]], align 8
1716 // CHECK: [[TMP10:%.*]] = load %struct.float32x2x2_t, ptr [[RETVAL]], align 8
1717 // CHECK: ret %struct.float32x2x2_t [[TMP10]]
1718 float32x2x2_t
test_vtrn_f32(float32x2_t a
, float32x2_t b
) {
1719 return vtrn_f32(a
, b
);
1722 // CHECK-LABEL: @test_vtrn_p8(
1723 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly8x8x2_t, align 8
1724 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly8x8x2_t, align 8
1725 // CHECK: [[VTRN_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1726 // CHECK: store <8 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1727 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <8 x i8>, ptr [[RETVAL_I]], i32 1
1728 // CHECK: [[VTRN1_I:%.*]] = shufflevector <8 x i8> %a, <8 x i8> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1729 // CHECK: store <8 x i8> [[VTRN1_I]], ptr [[TMP2]]
1730 // CHECK: [[TMP5:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL_I]], align 8
1731 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.poly8x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1732 // CHECK: [[TMP7:%.*]] = extractvalue %struct.poly8x8x2_t [[TMP5]], 0
1733 // CHECK: store [2 x <8 x i8>] [[TMP7]], ptr [[TMP6]], align 8
1734 // CHECK: [[TMP8:%.*]] = load %struct.poly8x8x2_t, ptr [[RETVAL]], align 8
1735 // CHECK: ret %struct.poly8x8x2_t [[TMP8]]
1736 poly8x8x2_t
test_vtrn_p8(poly8x8_t a
, poly8x8_t b
) {
1737 return vtrn_p8(a
, b
);
1740 // CHECK-LABEL: @test_vtrn_p16(
1741 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly16x4x2_t, align 8
1742 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly16x4x2_t, align 8
1743 // CHECK: [[TMP1:%.*]] = bitcast <4 x i16> %a to <8 x i8>
1744 // CHECK: [[TMP2:%.*]] = bitcast <4 x i16> %b to <8 x i8>
1745 // CHECK: [[VTRN_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1746 // CHECK: store <4 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1747 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i16>, ptr [[RETVAL_I]], i32 1
1748 // CHECK: [[VTRN1_I:%.*]] = shufflevector <4 x i16> %a, <4 x i16> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1749 // CHECK: store <4 x i16> [[VTRN1_I]], ptr [[TMP4]]
1750 // CHECK: [[TMP7:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL_I]], align 8
1751 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.poly16x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1752 // CHECK: [[TMP9:%.*]] = extractvalue %struct.poly16x4x2_t [[TMP7]], 0
1753 // CHECK: store [2 x <4 x i16>] [[TMP9]], ptr [[TMP8]], align 8
1754 // CHECK: [[TMP10:%.*]] = load %struct.poly16x4x2_t, ptr [[RETVAL]], align 8
1755 // CHECK: ret %struct.poly16x4x2_t [[TMP10]]
1756 poly16x4x2_t
test_vtrn_p16(poly16x4_t a
, poly16x4_t b
) {
1757 return vtrn_p16(a
, b
);
1760 // CHECK-LABEL: @test_vtrnq_s8(
1761 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int8x16x2_t, align 16
1762 // CHECK: [[RETVAL:%.*]] = alloca %struct.int8x16x2_t, align 16
1763 // CHECK: [[VTRN_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
1764 // CHECK: store <16 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1765 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1766 // CHECK: [[VTRN1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
1767 // CHECK: store <16 x i8> [[VTRN1_I]], ptr [[TMP2]]
1768 // CHECK: [[TMP5:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL_I]], align 16
1769 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.int8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1770 // CHECK: [[TMP7:%.*]] = extractvalue %struct.int8x16x2_t [[TMP5]], 0
1771 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1772 // CHECK: [[TMP8:%.*]] = load %struct.int8x16x2_t, ptr [[RETVAL]], align 16
1773 // CHECK: ret %struct.int8x16x2_t [[TMP8]]
1774 int8x16x2_t
test_vtrnq_s8(int8x16_t a
, int8x16_t b
) {
1775 return vtrnq_s8(a
, b
);
1778 // CHECK-LABEL: @test_vtrnq_s16(
1779 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int16x8x2_t, align 16
1780 // CHECK: [[RETVAL:%.*]] = alloca %struct.int16x8x2_t, align 16
1781 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1782 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1783 // CHECK: [[VTRN_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1784 // CHECK: store <8 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1785 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1786 // CHECK: [[VTRN1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1787 // CHECK: store <8 x i16> [[VTRN1_I]], ptr [[TMP4]]
1788 // CHECK: [[TMP7:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL_I]], align 16
1789 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1790 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int16x8x2_t [[TMP7]], 0
1791 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1792 // CHECK: [[TMP10:%.*]] = load %struct.int16x8x2_t, ptr [[RETVAL]], align 16
1793 // CHECK: ret %struct.int16x8x2_t [[TMP10]]
1794 int16x8x2_t
test_vtrnq_s16(int16x8_t a
, int16x8_t b
) {
1795 return vtrnq_s16(a
, b
);
1798 // CHECK-LABEL: @test_vtrnq_s32(
1799 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.int32x4x2_t, align 16
1800 // CHECK: [[RETVAL:%.*]] = alloca %struct.int32x4x2_t, align 16
1801 // CHECK: [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1802 // CHECK: [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1803 // CHECK: [[VTRN_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1804 // CHECK: store <4 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1805 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1806 // CHECK: [[VTRN1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1807 // CHECK: store <4 x i32> [[VTRN1_I]], ptr [[TMP4]]
1808 // CHECK: [[TMP7:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL_I]], align 16
1809 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.int32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1810 // CHECK: [[TMP9:%.*]] = extractvalue %struct.int32x4x2_t [[TMP7]], 0
1811 // CHECK: store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1812 // CHECK: [[TMP10:%.*]] = load %struct.int32x4x2_t, ptr [[RETVAL]], align 16
1813 // CHECK: ret %struct.int32x4x2_t [[TMP10]]
1814 int32x4x2_t
test_vtrnq_s32(int32x4_t a
, int32x4_t b
) {
1815 return vtrnq_s32(a
, b
);
1818 // CHECK-LABEL: @test_vtrnq_u8(
1819 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint8x16x2_t, align 16
1820 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint8x16x2_t, align 16
1821 // CHECK: [[VTRN_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
1822 // CHECK: store <16 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1823 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1824 // CHECK: [[VTRN1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
1825 // CHECK: store <16 x i8> [[VTRN1_I]], ptr [[TMP2]]
1826 // CHECK: [[TMP5:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL_I]], align 16
1827 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.uint8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1828 // CHECK: [[TMP7:%.*]] = extractvalue %struct.uint8x16x2_t [[TMP5]], 0
1829 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1830 // CHECK: [[TMP8:%.*]] = load %struct.uint8x16x2_t, ptr [[RETVAL]], align 16
1831 // CHECK: ret %struct.uint8x16x2_t [[TMP8]]
1832 uint8x16x2_t
test_vtrnq_u8(uint8x16_t a
, uint8x16_t b
) {
1833 return vtrnq_u8(a
, b
);
1836 // CHECK-LABEL: @test_vtrnq_u16(
1837 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint16x8x2_t, align 16
1838 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint16x8x2_t, align 16
1839 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1840 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1841 // CHECK: [[VTRN_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1842 // CHECK: store <8 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1843 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1844 // CHECK: [[VTRN1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1845 // CHECK: store <8 x i16> [[VTRN1_I]], ptr [[TMP4]]
1846 // CHECK: [[TMP7:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL_I]], align 16
1847 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1848 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint16x8x2_t [[TMP7]], 0
1849 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1850 // CHECK: [[TMP10:%.*]] = load %struct.uint16x8x2_t, ptr [[RETVAL]], align 16
1851 // CHECK: ret %struct.uint16x8x2_t [[TMP10]]
1852 uint16x8x2_t
test_vtrnq_u16(uint16x8_t a
, uint16x8_t b
) {
1853 return vtrnq_u16(a
, b
);
1856 // CHECK-LABEL: @test_vtrnq_u32(
1857 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.uint32x4x2_t, align 16
1858 // CHECK: [[RETVAL:%.*]] = alloca %struct.uint32x4x2_t, align 16
1859 // CHECK: [[TMP1:%.*]] = bitcast <4 x i32> %a to <16 x i8>
1860 // CHECK: [[TMP2:%.*]] = bitcast <4 x i32> %b to <16 x i8>
1861 // CHECK: [[VTRN_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1862 // CHECK: store <4 x i32> [[VTRN_I]], ptr [[RETVAL_I]]
1863 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x i32>, ptr [[RETVAL_I]], i32 1
1864 // CHECK: [[VTRN1_I:%.*]] = shufflevector <4 x i32> %a, <4 x i32> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1865 // CHECK: store <4 x i32> [[VTRN1_I]], ptr [[TMP4]]
1866 // CHECK: [[TMP7:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL_I]], align 16
1867 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.uint32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1868 // CHECK: [[TMP9:%.*]] = extractvalue %struct.uint32x4x2_t [[TMP7]], 0
1869 // CHECK: store [2 x <4 x i32>] [[TMP9]], ptr [[TMP8]], align 16
1870 // CHECK: [[TMP10:%.*]] = load %struct.uint32x4x2_t, ptr [[RETVAL]], align 16
1871 // CHECK: ret %struct.uint32x4x2_t [[TMP10]]
1872 uint32x4x2_t
test_vtrnq_u32(uint32x4_t a
, uint32x4_t b
) {
1873 return vtrnq_u32(a
, b
);
1876 // CHECK-LABEL: @test_vtrnq_f32(
1877 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.float32x4x2_t, align 16
1878 // CHECK: [[RETVAL:%.*]] = alloca %struct.float32x4x2_t, align 16
1879 // CHECK: [[TMP1:%.*]] = bitcast <4 x float> %a to <16 x i8>
1880 // CHECK: [[TMP2:%.*]] = bitcast <4 x float> %b to <16 x i8>
1881 // CHECK: [[VTRN_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1882 // CHECK: store <4 x float> [[VTRN_I]], ptr [[RETVAL_I]]
1883 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <4 x float>, ptr [[RETVAL_I]], i32 1
1884 // CHECK: [[VTRN1_I:%.*]] = shufflevector <4 x float> %a, <4 x float> %b, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1885 // CHECK: store <4 x float> [[VTRN1_I]], ptr [[TMP4]]
1886 // CHECK: [[TMP7:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL_I]], align 16
1887 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.float32x4x2_t, ptr [[RETVAL]], i32 0, i32 0
1888 // CHECK: [[TMP9:%.*]] = extractvalue %struct.float32x4x2_t [[TMP7]], 0
1889 // CHECK: store [2 x <4 x float>] [[TMP9]], ptr [[TMP8]], align 16
1890 // CHECK: [[TMP10:%.*]] = load %struct.float32x4x2_t, ptr [[RETVAL]], align 16
1891 // CHECK: ret %struct.float32x4x2_t [[TMP10]]
1892 float32x4x2_t
test_vtrnq_f32(float32x4_t a
, float32x4_t b
) {
1893 return vtrnq_f32(a
, b
);
1896 // CHECK-LABEL: @test_vtrnq_p8(
1897 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly8x16x2_t, align 16
1898 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly8x16x2_t, align 16
1899 // CHECK: [[VTRN_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
1900 // CHECK: store <16 x i8> [[VTRN_I]], ptr [[RETVAL_I]]
1901 // CHECK: [[TMP2:%.*]] = getelementptr inbounds <16 x i8>, ptr [[RETVAL_I]], i32 1
1902 // CHECK: [[VTRN1_I:%.*]] = shufflevector <16 x i8> %a, <16 x i8> %b, <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
1903 // CHECK: store <16 x i8> [[VTRN1_I]], ptr [[TMP2]]
1904 // CHECK: [[TMP5:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL_I]], align 16
1905 // CHECK: [[TMP6:%.*]] = getelementptr inbounds nuw %struct.poly8x16x2_t, ptr [[RETVAL]], i32 0, i32 0
1906 // CHECK: [[TMP7:%.*]] = extractvalue %struct.poly8x16x2_t [[TMP5]], 0
1907 // CHECK: store [2 x <16 x i8>] [[TMP7]], ptr [[TMP6]], align 16
1908 // CHECK: [[TMP8:%.*]] = load %struct.poly8x16x2_t, ptr [[RETVAL]], align 16
1909 // CHECK: ret %struct.poly8x16x2_t [[TMP8]]
1910 poly8x16x2_t
test_vtrnq_p8(poly8x16_t a
, poly8x16_t b
) {
1911 return vtrnq_p8(a
, b
);
1914 // CHECK-LABEL: @test_vtrnq_p16(
1915 // CHECK: [[RETVAL_I:%.*]] = alloca %struct.poly16x8x2_t, align 16
1916 // CHECK: [[RETVAL:%.*]] = alloca %struct.poly16x8x2_t, align 16
1917 // CHECK: [[TMP1:%.*]] = bitcast <8 x i16> %a to <16 x i8>
1918 // CHECK: [[TMP2:%.*]] = bitcast <8 x i16> %b to <16 x i8>
1919 // CHECK: [[VTRN_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
1920 // CHECK: store <8 x i16> [[VTRN_I]], ptr [[RETVAL_I]]
1921 // CHECK: [[TMP4:%.*]] = getelementptr inbounds <8 x i16>, ptr [[RETVAL_I]], i32 1
1922 // CHECK: [[VTRN1_I:%.*]] = shufflevector <8 x i16> %a, <8 x i16> %b, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
1923 // CHECK: store <8 x i16> [[VTRN1_I]], ptr [[TMP4]]
1924 // CHECK: [[TMP7:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL_I]], align 16
1925 // CHECK: [[TMP8:%.*]] = getelementptr inbounds nuw %struct.poly16x8x2_t, ptr [[RETVAL]], i32 0, i32 0
1926 // CHECK: [[TMP9:%.*]] = extractvalue %struct.poly16x8x2_t [[TMP7]], 0
1927 // CHECK: store [2 x <8 x i16>] [[TMP9]], ptr [[TMP8]], align 16
1928 // CHECK: [[TMP10:%.*]] = load %struct.poly16x8x2_t, ptr [[RETVAL]], align 16
1929 // CHECK: ret %struct.poly16x8x2_t [[TMP10]]
1930 poly16x8x2_t
test_vtrnq_p16(poly16x8_t a
, poly16x8_t b
) {
1931 return vtrnq_p16(a
, b
);