Clang Project

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