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