1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -emit-llvm -o - -Wall -Werror | FileCheck %s
2 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
3
4
5 #include <immintrin.h>
6
7 // NOTE: This should match the tests in llvm/test/CodeGen/X86/avx2-intrinsics-fast-isel.ll
8
test_mm256_abs_epi8(__m256i a)9 __m256i test_mm256_abs_epi8(__m256i a) {
10 // CHECK-LABEL: test_mm256_abs_epi8
11 // CHECK: [[ABS:%.*]] = call <32 x i8> @llvm.abs.v32i8(<32 x i8> %{{.*}}, i1 false)
12 return _mm256_abs_epi8(a);
13 }
14
test_mm256_abs_epi16(__m256i a)15 __m256i test_mm256_abs_epi16(__m256i a) {
16 // CHECK-LABEL: test_mm256_abs_epi16
17 // CHECK: [[ABS:%.*]] = call <16 x i16> @llvm.abs.v16i16(<16 x i16> %{{.*}}, i1 false)
18 return _mm256_abs_epi16(a);
19 }
20
test_mm256_abs_epi32(__m256i a)21 __m256i test_mm256_abs_epi32(__m256i a) {
22 // CHECK-LABEL: test_mm256_abs_epi32
23 // CHECK: [[ABS:%.*]] = call <8 x i32> @llvm.abs.v8i32(<8 x i32> %{{.*}}, i1 false)
24 return _mm256_abs_epi32(a);
25 }
26
test_mm256_add_epi8(__m256i a,__m256i b)27 __m256i test_mm256_add_epi8(__m256i a, __m256i b) {
28 // CHECK-LABEL: test_mm256_add_epi8
29 // CHECK: add <32 x i8>
30 return _mm256_add_epi8(a, b);
31 }
32
test_mm256_add_epi16(__m256i a,__m256i b)33 __m256i test_mm256_add_epi16(__m256i a, __m256i b) {
34 // CHECK-LABEL: test_mm256_add_epi16
35 // CHECK: add <16 x i16>
36 return _mm256_add_epi16(a, b);
37 }
38
test_mm256_add_epi32(__m256i a,__m256i b)39 __m256i test_mm256_add_epi32(__m256i a, __m256i b) {
40 // CHECK-LABEL: test_mm256_add_epi32
41 // CHECK: add <8 x i32>
42 return _mm256_add_epi32(a, b);
43 }
44
test_mm256_add_epi64(__m256i a,__m256i b)45 __m256i test_mm256_add_epi64(__m256i a, __m256i b) {
46 // CHECK-LABEL: test_mm256_add_epi64
47 // CHECK: add <4 x i64>
48 return _mm256_add_epi64(a, b);
49 }
50
test_mm256_adds_epi8(__m256i a,__m256i b)51 __m256i test_mm256_adds_epi8(__m256i a, __m256i b) {
52 // CHECK-LABEL: test_mm256_adds_epi8
53 // CHECK: call <32 x i8> @llvm.sadd.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
54 return _mm256_adds_epi8(a, b);
55 }
56
test_mm256_adds_epi16(__m256i a,__m256i b)57 __m256i test_mm256_adds_epi16(__m256i a, __m256i b) {
58 // CHECK-LABEL: test_mm256_adds_epi16
59 // CHECK: call <16 x i16> @llvm.sadd.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
60 return _mm256_adds_epi16(a, b);
61 }
62
test_mm256_adds_epu8(__m256i a,__m256i b)63 __m256i test_mm256_adds_epu8(__m256i a, __m256i b) {
64 // CHECK-LABEL: test_mm256_adds_epu8
65 // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.paddus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
66 // CHECK: call <32 x i8> @llvm.uadd.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
67 return _mm256_adds_epu8(a, b);
68 }
69
test_mm256_adds_epu16(__m256i a,__m256i b)70 __m256i test_mm256_adds_epu16(__m256i a, __m256i b) {
71 // CHECK-LABEL: test_mm256_adds_epu16
72 // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.paddus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
73 // CHECK: call <16 x i16> @llvm.uadd.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
74 return _mm256_adds_epu16(a, b);
75 }
76
test_mm256_alignr_epi8(__m256i a,__m256i b)77 __m256i test_mm256_alignr_epi8(__m256i a, __m256i b) {
78 // CHECK-LABEL: test_mm256_alignr_epi8
79 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 33, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48, i32 49>
80 return _mm256_alignr_epi8(a, b, 2);
81 }
82
test2_mm256_alignr_epi8(__m256i a,__m256i b)83 __m256i test2_mm256_alignr_epi8(__m256i a, __m256i b) {
84 // CHECK-LABEL: test2_mm256_alignr_epi8
85 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> zeroinitializer, <32 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48>
86 return _mm256_alignr_epi8(a, b, 17);
87 }
88
test_mm256_and_si256(__m256i a,__m256i b)89 __m256i test_mm256_and_si256(__m256i a, __m256i b) {
90 // CHECK-LABEL: test_mm256_and_si256
91 // CHECK: and <4 x i64>
92 return _mm256_and_si256(a, b);
93 }
94
test_mm256_andnot_si256(__m256i a,__m256i b)95 __m256i test_mm256_andnot_si256(__m256i a, __m256i b) {
96 // CHECK-LABEL: test_mm256_andnot_si256
97 // CHECK: xor <4 x i64>
98 // CHECK: and <4 x i64>
99 return _mm256_andnot_si256(a, b);
100 }
101
test_mm256_avg_epu8(__m256i a,__m256i b)102 __m256i test_mm256_avg_epu8(__m256i a, __m256i b) {
103 // CHECK-LABEL: test_mm256_avg_epu8
104 // CHECK: call <32 x i8> @llvm.x86.avx2.pavg.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
105 return _mm256_avg_epu8(a, b);
106 }
107
test_mm256_avg_epu16(__m256i a,__m256i b)108 __m256i test_mm256_avg_epu16(__m256i a, __m256i b) {
109 // CHECK-LABEL: test_mm256_avg_epu16
110 // CHECK: call <16 x i16> @llvm.x86.avx2.pavg.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
111 return _mm256_avg_epu16(a, b);
112 }
113
114 // FIXME: We should also lower the __builtin_ia32_pblendw128 (and similar)
115 // functions to this IR. In the future we could delete the corresponding
116 // intrinsic in LLVM if it's not being used anymore.
test_mm256_blend_epi16(__m256i a,__m256i b)117 __m256i test_mm256_blend_epi16(__m256i a, __m256i b) {
118 // CHECK-LABEL: test_mm256_blend_epi16
119 // CHECK-NOT: @llvm.x86.avx2.pblendw
120 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 0, i32 17, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 25, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
121 return _mm256_blend_epi16(a, b, 2);
122 }
123
test_mm_blend_epi32(__m128i a,__m128i b)124 __m128i test_mm_blend_epi32(__m128i a, __m128i b) {
125 // CHECK-LABEL: test_mm_blend_epi32
126 // CHECK-NOT: @llvm.x86.avx2.pblendd.128
127 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3>
128 return _mm_blend_epi32(a, b, 0x05);
129 }
130
test_mm256_blend_epi32(__m256i a,__m256i b)131 __m256i test_mm256_blend_epi32(__m256i a, __m256i b) {
132 // CHECK-LABEL: test_mm256_blend_epi32
133 // CHECK-NOT: @llvm.x86.avx2.pblendd.256
134 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 8, i32 1, i32 10, i32 3, i32 12, i32 13, i32 6, i32 7>
135 return _mm256_blend_epi32(a, b, 0x35);
136 }
137
test_mm256_blendv_epi8(__m256i a,__m256i b,__m256i m)138 __m256i test_mm256_blendv_epi8(__m256i a, __m256i b, __m256i m) {
139 // CHECK-LABEL: test_mm256_blendv_epi8
140 // CHECK: call <32 x i8> @llvm.x86.avx2.pblendvb(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}})
141 return _mm256_blendv_epi8(a, b, m);
142 }
143
test_mm_broadcastb_epi8(__m128i a)144 __m128i test_mm_broadcastb_epi8(__m128i a) {
145 // CHECK-LABEL: test_mm_broadcastb_epi8
146 // CHECK-NOT: @llvm.x86.avx2.pbroadcastb.128
147 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> zeroinitializer
148 return _mm_broadcastb_epi8(a);
149 }
150
test_mm256_broadcastb_epi8(__m128i a)151 __m256i test_mm256_broadcastb_epi8(__m128i a) {
152 // CHECK-LABEL: test_mm256_broadcastb_epi8
153 // CHECK-NOT: @llvm.x86.avx2.pbroadcastb.256
154 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <32 x i32> zeroinitializer
155 return _mm256_broadcastb_epi8(a);
156 }
157
test_mm_broadcastd_epi32(__m128i a)158 __m128i test_mm_broadcastd_epi32(__m128i a) {
159 // CHECK-LABEL: test_mm_broadcastd_epi32
160 // CHECK-NOT: @llvm.x86.avx2.pbroadcastd.128
161 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> zeroinitializer
162 return _mm_broadcastd_epi32(a);
163 }
164
test_mm256_broadcastd_epi32(__m128i a)165 __m256i test_mm256_broadcastd_epi32(__m128i a) {
166 // CHECK-LABEL: test_mm256_broadcastd_epi32
167 // CHECK-NOT: @llvm.x86.avx2.pbroadcastd.256
168 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <8 x i32> zeroinitializer
169 return _mm256_broadcastd_epi32(a);
170 }
171
test_mm_broadcastq_epi64(__m128i a)172 __m128i test_mm_broadcastq_epi64(__m128i a) {
173 // CHECK-LABEL: test_mm_broadcastq_epi64
174 // CHECK-NOT: @llvm.x86.avx2.pbroadcastq.128
175 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> zeroinitializer
176 return _mm_broadcastq_epi64(a);
177 }
178
test_mm256_broadcastq_epi64(__m128i a)179 __m256i test_mm256_broadcastq_epi64(__m128i a) {
180 // CHECK-LABEL: test_mm256_broadcastq_epi64
181 // CHECK-NOT: @llvm.x86.avx2.pbroadcastq.256
182 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> zeroinitializer
183 return _mm256_broadcastq_epi64(a);
184 }
185
test_mm_broadcastsd_pd(__m128d a)186 __m128d test_mm_broadcastsd_pd(__m128d a) {
187 // CHECK-LABEL: test_mm_broadcastsd_pd
188 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer
189 return _mm_broadcastsd_pd(a);
190 }
191
test_mm256_broadcastsd_pd(__m128d a)192 __m256d test_mm256_broadcastsd_pd(__m128d a) {
193 // CHECK-LABEL: test_mm256_broadcastsd_pd
194 // CHECK-NOT: @llvm.x86.avx2.vbroadcast.sd.pd.256
195 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> zeroinitializer
196 return _mm256_broadcastsd_pd(a);
197 }
198
test_mm256_broadcastsi128_si256(__m128i a)199 __m256i test_mm256_broadcastsi128_si256(__m128i a) {
200 // CHECK-LABEL: test_mm256_broadcastsi128_si256
201 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
202 return _mm256_broadcastsi128_si256(a);
203 }
204
test_mm_broadcastsi128_si256(__m128i a)205 __m256i test_mm_broadcastsi128_si256(__m128i a) {
206 // CHECK-LABEL: test_mm_broadcastsi128_si256
207 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
208 return _mm_broadcastsi128_si256(a);
209 }
210
test_mm_broadcastss_ps(__m128 a)211 __m128 test_mm_broadcastss_ps(__m128 a) {
212 // CHECK-LABEL: test_mm_broadcastss_ps
213 // CHECK-NOT: @llvm.x86.avx2.vbroadcast.ss.ps
214 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> zeroinitializer
215 return _mm_broadcastss_ps(a);
216 }
217
test_mm256_broadcastss_ps(__m128 a)218 __m256 test_mm256_broadcastss_ps(__m128 a) {
219 // CHECK-LABEL: test_mm256_broadcastss_ps
220 // CHECK-NOT: @llvm.x86.avx2.vbroadcast.ss.ps.256
221 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> zeroinitializer
222 return _mm256_broadcastss_ps(a);
223 }
224
test_mm_broadcastw_epi16(__m128i a)225 __m128i test_mm_broadcastw_epi16(__m128i a) {
226 // CHECK-LABEL: test_mm_broadcastw_epi16
227 // CHECK-NOT: @llvm.x86.avx2.pbroadcastw.128
228 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> zeroinitializer
229 return _mm_broadcastw_epi16(a);
230 }
231
test_mm256_broadcastw_epi16(__m128i a)232 __m256i test_mm256_broadcastw_epi16(__m128i a) {
233 // CHECK-LABEL: test_mm256_broadcastw_epi16
234 // CHECK-NOT: @llvm.x86.avx2.pbroadcastw.256
235 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i32> zeroinitializer
236 return _mm256_broadcastw_epi16(a);
237 }
238
test_mm256_bslli_epi128(__m256i a)239 __m256i test_mm256_bslli_epi128(__m256i a) {
240 // CHECK-LABEL: test_mm256_bslli_epi128
241 // CHECK: shufflevector <32 x i8> zeroinitializer, <32 x i8> %{{.*}}, <32 x i32> <i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60>
242 return _mm256_bslli_epi128(a, 3);
243 }
244
test_mm256_bsrli_epi128(__m256i a)245 __m256i test_mm256_bsrli_epi128(__m256i a) {
246 // CHECK-LABEL: test_mm256_bsrli_epi128
247 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> zeroinitializer, <32 x i32> <i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50>
248 return _mm256_bsrli_epi128(a, 3);
249 }
250
test_mm256_cmpeq_epi8(__m256i a,__m256i b)251 __m256i test_mm256_cmpeq_epi8(__m256i a, __m256i b) {
252 // CHECK-LABEL: test_mm256_cmpeq_epi8
253 // CHECK: icmp eq <32 x i8>
254 return _mm256_cmpeq_epi8(a, b);
255 }
256
test_mm256_cmpeq_epi16(__m256i a,__m256i b)257 __m256i test_mm256_cmpeq_epi16(__m256i a, __m256i b) {
258 // CHECK-LABEL: test_mm256_cmpeq_epi16
259 // CHECK: icmp eq <16 x i16>
260 return _mm256_cmpeq_epi16(a, b);
261 }
262
test_mm256_cmpeq_epi32(__m256i a,__m256i b)263 __m256i test_mm256_cmpeq_epi32(__m256i a, __m256i b) {
264 // CHECK-LABEL: test_mm256_cmpeq_epi32
265 // CHECK: icmp eq <8 x i32>
266 return _mm256_cmpeq_epi32(a, b);
267 }
268
test_mm256_cmpeq_epi64(__m256i a,__m256i b)269 __m256i test_mm256_cmpeq_epi64(__m256i a, __m256i b) {
270 // CHECK-LABEL: test_mm256_cmpeq_epi64
271 // CHECK: icmp eq <4 x i64>
272 return _mm256_cmpeq_epi64(a, b);
273 }
274
test_mm256_cmpgt_epi8(__m256i a,__m256i b)275 __m256i test_mm256_cmpgt_epi8(__m256i a, __m256i b) {
276 // CHECK-LABEL: test_mm256_cmpgt_epi8
277 // CHECK: icmp sgt <32 x i8>
278 return _mm256_cmpgt_epi8(a, b);
279 }
280
test_mm256_cmpgt_epi16(__m256i a,__m256i b)281 __m256i test_mm256_cmpgt_epi16(__m256i a, __m256i b) {
282 // CHECK-LABEL: test_mm256_cmpgt_epi16
283 // CHECK: icmp sgt <16 x i16>
284 return _mm256_cmpgt_epi16(a, b);
285 }
286
test_mm256_cmpgt_epi32(__m256i a,__m256i b)287 __m256i test_mm256_cmpgt_epi32(__m256i a, __m256i b) {
288 // CHECK-LABEL: test_mm256_cmpgt_epi32
289 // CHECK: icmp sgt <8 x i32>
290 return _mm256_cmpgt_epi32(a, b);
291 }
292
test_mm256_cmpgt_epi64(__m256i a,__m256i b)293 __m256i test_mm256_cmpgt_epi64(__m256i a, __m256i b) {
294 // CHECK-LABEL: test_mm256_cmpgt_epi64
295 // CHECK: icmp sgt <4 x i64>
296 return _mm256_cmpgt_epi64(a, b);
297 }
298
test_mm256_cvtepi8_epi16(__m128i a)299 __m256i test_mm256_cvtepi8_epi16(__m128i a) {
300 // CHECK-LABEL: test_mm256_cvtepi8_epi16
301 // CHECK: sext <16 x i8> %{{.*}} to <16 x i16>
302 return _mm256_cvtepi8_epi16(a);
303 }
304
test_mm256_cvtepi8_epi32(__m128i a)305 __m256i test_mm256_cvtepi8_epi32(__m128i a) {
306 // CHECK-LABEL: test_mm256_cvtepi8_epi32
307 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
308 // CHECK: sext <8 x i8> %{{.*}} to <8 x i32>
309 return _mm256_cvtepi8_epi32(a);
310 }
311
test_mm256_cvtepi8_epi64(__m128i a)312 __m256i test_mm256_cvtepi8_epi64(__m128i a) {
313 // CHECK-LABEL: test_mm256_cvtepi8_epi64
314 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
315 // CHECK: sext <4 x i8> %{{.*}} to <4 x i64>
316 return _mm256_cvtepi8_epi64(a);
317 }
318
test_mm256_cvtepi16_epi32(__m128i a)319 __m256i test_mm256_cvtepi16_epi32(__m128i a) {
320 // CHECK-LABEL: test_mm256_cvtepi16_epi32
321 // CHECK: sext <8 x i16> %{{.*}} to <8 x i32>
322 return _mm256_cvtepi16_epi32(a);
323 }
324
test_mm256_cvtepi16_epi64(__m128i a)325 __m256i test_mm256_cvtepi16_epi64(__m128i a) {
326 // CHECK-LABEL: test_mm256_cvtepi16_epi64
327 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
328 // CHECK: sext <4 x i16> %{{.*}} to <4 x i64>
329 return _mm256_cvtepi16_epi64(a);
330 }
331
test_mm256_cvtepi32_epi64(__m128i a)332 __m256i test_mm256_cvtepi32_epi64(__m128i a) {
333 // CHECK-LABEL: test_mm256_cvtepi32_epi64
334 // CHECK: sext <4 x i32> %{{.*}} to <4 x i64>
335 return _mm256_cvtepi32_epi64(a);
336 }
337
test_mm256_cvtepu8_epi16(__m128i a)338 __m256i test_mm256_cvtepu8_epi16(__m128i a) {
339 // CHECK-LABEL: test_mm256_cvtepu8_epi16
340 // CHECK: zext <16 x i8> %{{.*}} to <16 x i16>
341 return _mm256_cvtepu8_epi16(a);
342 }
343
test_mm256_cvtepu8_epi32(__m128i a)344 __m256i test_mm256_cvtepu8_epi32(__m128i a) {
345 // CHECK-LABEL: test_mm256_cvtepu8_epi32
346 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
347 // CHECK: zext <8 x i8> %{{.*}} to <8 x i32>
348 return _mm256_cvtepu8_epi32(a);
349 }
350
test_mm256_cvtepu8_epi64(__m128i a)351 __m256i test_mm256_cvtepu8_epi64(__m128i a) {
352 // CHECK-LABEL: test_mm256_cvtepu8_epi64
353 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
354 // CHECK: zext <4 x i8> %{{.*}} to <4 x i64>
355 return _mm256_cvtepu8_epi64(a);
356 }
357
test_mm256_cvtepu16_epi32(__m128i a)358 __m256i test_mm256_cvtepu16_epi32(__m128i a) {
359 // CHECK-LABEL: test_mm256_cvtepu16_epi32
360 // CHECK: zext <8 x i16> {{.*}} to <8 x i32>
361 return _mm256_cvtepu16_epi32(a);
362 }
363
test_mm256_cvtepu16_epi64(__m128i a)364 __m256i test_mm256_cvtepu16_epi64(__m128i a) {
365 // CHECK-LABEL: test_mm256_cvtepu16_epi64
366 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
367 // CHECK: zext <4 x i16> %{{.*}} to <4 x i64>
368 return _mm256_cvtepu16_epi64(a);
369 }
370
test_mm256_cvtepu32_epi64(__m128i a)371 __m256i test_mm256_cvtepu32_epi64(__m128i a) {
372 // CHECK-LABEL: test_mm256_cvtepu32_epi64
373 // CHECK: zext <4 x i32> %{{.*}} to <4 x i64>
374 return _mm256_cvtepu32_epi64(a);
375 }
376
test0_mm256_extracti128_si256_0(__m256i a)377 __m128i test0_mm256_extracti128_si256_0(__m256i a) {
378 // CHECK-LABEL: test0_mm256_extracti128_si256
379 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 0, i32 1>
380 return _mm256_extracti128_si256(a, 0);
381 }
382
test1_mm256_extracti128_si256_1(__m256i a)383 __m128i test1_mm256_extracti128_si256_1(__m256i a) {
384 // CHECK-LABEL: test1_mm256_extracti128_si256
385 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 2, i32 3>
386 return _mm256_extracti128_si256(a, 1);
387 }
388
389 // Immediate should be truncated to one bit.
test2_mm256_extracti128_si256(__m256i a)390 __m128i test2_mm256_extracti128_si256(__m256i a) {
391 // CHECK-LABEL: test2_mm256_extracti128_si256
392 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 0, i32 1>
393 return _mm256_extracti128_si256(a, 0);
394 }
395
test_mm256_hadd_epi16(__m256i a,__m256i b)396 __m256i test_mm256_hadd_epi16(__m256i a, __m256i b) {
397 // CHECK-LABEL: test_mm256_hadd_epi16
398 // CHECK: call <16 x i16> @llvm.x86.avx2.phadd.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
399 return _mm256_hadd_epi16(a, b);
400 }
401
test_mm256_hadd_epi32(__m256i a,__m256i b)402 __m256i test_mm256_hadd_epi32(__m256i a, __m256i b) {
403 // CHECK-LABEL: test_mm256_hadd_epi32
404 // CHECK: call <8 x i32> @llvm.x86.avx2.phadd.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
405 return _mm256_hadd_epi32(a, b);
406 }
407
test_mm256_hadds_epi16(__m256i a,__m256i b)408 __m256i test_mm256_hadds_epi16(__m256i a, __m256i b) {
409 // CHECK-LABEL: test_mm256_hadds_epi16
410 // CHECK:call <16 x i16> @llvm.x86.avx2.phadd.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
411 return _mm256_hadds_epi16(a, b);
412 }
413
test_mm256_hsub_epi16(__m256i a,__m256i b)414 __m256i test_mm256_hsub_epi16(__m256i a, __m256i b) {
415 // CHECK-LABEL: test_mm256_hsub_epi16
416 // CHECK: call <16 x i16> @llvm.x86.avx2.phsub.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
417 return _mm256_hsub_epi16(a, b);
418 }
419
test_mm256_hsub_epi32(__m256i a,__m256i b)420 __m256i test_mm256_hsub_epi32(__m256i a, __m256i b) {
421 // CHECK-LABEL: test_mm256_hsub_epi32
422 // CHECK: call <8 x i32> @llvm.x86.avx2.phsub.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
423 return _mm256_hsub_epi32(a, b);
424 }
425
test_mm256_hsubs_epi16(__m256i a,__m256i b)426 __m256i test_mm256_hsubs_epi16(__m256i a, __m256i b) {
427 // CHECK-LABEL: test_mm256_hsubs_epi16
428 // CHECK:call <16 x i16> @llvm.x86.avx2.phsub.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
429 return _mm256_hsubs_epi16(a, b);
430 }
431
test_mm_i32gather_epi32(int const * b,__m128i c)432 __m128i test_mm_i32gather_epi32(int const *b, __m128i c) {
433 // CHECK-LABEL: test_mm_i32gather_epi32
434 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.d.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
435 return _mm_i32gather_epi32(b, c, 2);
436 }
437
test_mm_mask_i32gather_epi32(__m128i a,int const * b,__m128i c,__m128i d)438 __m128i test_mm_mask_i32gather_epi32(__m128i a, int const *b, __m128i c, __m128i d) {
439 // CHECK-LABEL: test_mm_mask_i32gather_epi32
440 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.d.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
441 return _mm_mask_i32gather_epi32(a, b, c, d, 2);
442 }
443
test_mm256_i32gather_epi32(int const * b,__m256i c)444 __m256i test_mm256_i32gather_epi32(int const *b, __m256i c) {
445 // CHECK-LABEL: test_mm256_i32gather_epi32
446 // CHECK: call <8 x i32> @llvm.x86.avx2.gather.d.d.256(<8 x i32> %{{.*}}, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 2)
447 return _mm256_i32gather_epi32(b, c, 2);
448 }
449
test_mm256_mask_i32gather_epi32(__m256i a,int const * b,__m256i c,__m256i d)450 __m256i test_mm256_mask_i32gather_epi32(__m256i a, int const *b, __m256i c, __m256i d) {
451 // CHECK-LABEL: test_mm256_mask_i32gather_epi32
452 // CHECK: call <8 x i32> @llvm.x86.avx2.gather.d.d.256(<8 x i32> %{{.*}}, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 2)
453 return _mm256_mask_i32gather_epi32(a, b, c, d, 2);
454 }
455
test_mm_i32gather_epi64(long long const * b,__m128i c)456 __m128i test_mm_i32gather_epi64(long long const *b, __m128i c) {
457 // CHECK-LABEL: test_mm_i32gather_epi64
458 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.d.q(<2 x i64> zeroinitializer, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
459 return _mm_i32gather_epi64(b, c, 2);
460 }
461
test_mm_mask_i32gather_epi64(__m128i a,long long const * b,__m128i c,__m128i d)462 __m128i test_mm_mask_i32gather_epi64(__m128i a, long long const *b, __m128i c, __m128i d) {
463 // CHECK-LABEL: test_mm_mask_i32gather_epi64
464 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.d.q(<2 x i64> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
465 return _mm_mask_i32gather_epi64(a, b, c, d, 2);
466 }
467
test_mm256_i32gather_epi64(long long const * b,__m128i c)468 __m256i test_mm256_i32gather_epi64(long long const *b, __m128i c) {
469 // CHECK-LABEL: test_mm256_i32gather_epi64
470 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.d.q.256(<4 x i64> zeroinitializer, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
471 return _mm256_i32gather_epi64(b, c, 2);
472 }
473
test_mm256_mask_i32gather_epi64(__m256i a,long long const * b,__m128i c,__m256i d)474 __m256i test_mm256_mask_i32gather_epi64(__m256i a, long long const *b, __m128i c, __m256i d) {
475 // CHECK-LABEL: test_mm256_mask_i32gather_epi64
476 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.d.q.256(<4 x i64> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
477 return _mm256_mask_i32gather_epi64(a, b, c, d, 2);
478 }
479
test_mm_i32gather_pd(double const * b,__m128i c)480 __m128d test_mm_i32gather_pd(double const *b, __m128i c) {
481 // CHECK-LABEL: test_mm_i32gather_pd
482 // CHECK: [[CMP:%.*]] = fcmp oeq <2 x double>
483 // CHECK-NEXT: [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
484 // CHECK-NEXT: [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
485 // CHECK: call <2 x double> @llvm.x86.avx2.gather.d.pd(<2 x double> zeroinitializer, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x double> %{{.*}}, i8 2)
486 return _mm_i32gather_pd(b, c, 2);
487 }
488
test_mm_mask_i32gather_pd(__m128d a,double const * b,__m128i c,__m128d d)489 __m128d test_mm_mask_i32gather_pd(__m128d a, double const *b, __m128i c, __m128d d) {
490 // CHECK-LABEL: test_mm_mask_i32gather_pd
491 // CHECK: call <2 x double> @llvm.x86.avx2.gather.d.pd(<2 x double> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <2 x double> %{{.*}}, i8 2)
492 return _mm_mask_i32gather_pd(a, b, c, d, 2);
493 }
494
test_mm256_i32gather_pd(double const * b,__m128i c)495 __m256d test_mm256_i32gather_pd(double const *b, __m128i c) {
496 // CHECK-LABEL: test_mm256_i32gather_pd
497 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x double>
498 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i64>
499 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i64> [[SEXT]] to <4 x double>
500 // CHECK: call <4 x double> @llvm.x86.avx2.gather.d.pd.256(<4 x double> zeroinitializer, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x double> %{{.*}}, i8 2)
501 return _mm256_i32gather_pd(b, c, 2);
502 }
503
test_mm256_mask_i32gather_pd(__m256d a,double const * b,__m128i c,__m256d d)504 __m256d test_mm256_mask_i32gather_pd(__m256d a, double const *b, __m128i c, __m256d d) {
505 // CHECK-LABEL: test_mm256_mask_i32gather_pd
506 // CHECK: call <4 x double> @llvm.x86.avx2.gather.d.pd.256(<4 x double> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x double> %{{.*}}, i8 2)
507 return _mm256_mask_i32gather_pd(a, b, c, d, 2);
508 }
509
test_mm_i32gather_ps(float const * b,__m128i c)510 __m128 test_mm_i32gather_ps(float const *b, __m128i c) {
511 // CHECK-LABEL: test_mm_i32gather_ps
512 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x float>
513 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
514 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
515 // CHECK: call <4 x float> @llvm.x86.avx2.gather.d.ps(<4 x float> zeroinitializer, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}, i8 2)
516 return _mm_i32gather_ps(b, c, 2);
517 }
518
test_mm_mask_i32gather_ps(__m128 a,float const * b,__m128i c,__m128 d)519 __m128 test_mm_mask_i32gather_ps(__m128 a, float const *b, __m128i c, __m128 d) {
520 // CHECK-LABEL: test_mm_mask_i32gather_ps
521 // CHECK: call <4 x float> @llvm.x86.avx2.gather.d.ps(<4 x float> %{{.*}}, i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}, i8 2)
522 return _mm_mask_i32gather_ps(a, b, c, d, 2);
523 }
524
test_mm256_i32gather_ps(float const * b,__m256i c)525 __m256 test_mm256_i32gather_ps(float const *b, __m256i c) {
526 // CHECK-LABEL: test_mm256_i32gather_ps
527 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x float>
528 // CHECK-NEXT: [[SEXT:%.*]] = sext <8 x i1> [[CMP]] to <8 x i32>
529 // CHECK-NEXT: [[BC:%.*]] = bitcast <8 x i32> [[SEXT]] to <8 x float>
530 // CHECK: call <8 x float> @llvm.x86.avx2.gather.d.ps.256(<8 x float> zeroinitializer, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 2)
531 return _mm256_i32gather_ps(b, c, 2);
532 }
533
test_mm256_mask_i32gather_ps(__m256 a,float const * b,__m256i c,__m256 d)534 __m256 test_mm256_mask_i32gather_ps(__m256 a, float const *b, __m256i c, __m256 d) {
535 // CHECK-LABEL: test_mm256_mask_i32gather_ps
536 // CHECK: call <8 x float> @llvm.x86.avx2.gather.d.ps.256(<8 x float> %{{.*}}, i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 2)
537 return _mm256_mask_i32gather_ps(a, b, c, d, 2);
538 }
539
test_mm_i64gather_epi32(int const * b,__m128i c)540 __m128i test_mm_i64gather_epi32(int const *b, __m128i c) {
541 // CHECK-LABEL: test_mm_i64gather_epi32
542 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
543 return _mm_i64gather_epi32(b, c, 2);
544 }
545
test_mm_mask_i64gather_epi32(__m128i a,int const * b,__m128i c,__m128i d)546 __m128i test_mm_mask_i64gather_epi32(__m128i a, int const *b, __m128i c, __m128i d) {
547 // CHECK-LABEL: test_mm_mask_i64gather_epi32
548 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d(<4 x i32> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
549 return _mm_mask_i64gather_epi32(a, b, c, d, 2);
550 }
551
test_mm256_i64gather_epi32(int const * b,__m256i c)552 __m128i test_mm256_i64gather_epi32(int const *b, __m256i c) {
553 // CHECK-LABEL: test_mm256_i64gather_epi32
554 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d.256(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
555 return _mm256_i64gather_epi32(b, c, 2);
556 }
557
test_mm256_mask_i64gather_epi32(__m128i a,int const * b,__m256i c,__m128i d)558 __m128i test_mm256_mask_i64gather_epi32(__m128i a, int const *b, __m256i c, __m128i d) {
559 // CHECK-LABEL: test_mm256_mask_i64gather_epi32
560 // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d.256(<4 x i32> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
561 return _mm256_mask_i64gather_epi32(a, b, c, d, 2);
562 }
563
test_mm_i64gather_epi64(long long const * b,__m128i c)564 __m128i test_mm_i64gather_epi64(long long const *b, __m128i c) {
565 // CHECK-LABEL: test_mm_i64gather_epi64
566 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.q.q(<2 x i64> zeroinitializer, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
567 return _mm_i64gather_epi64(b, c, 2);
568 }
569
test_mm_mask_i64gather_epi64(__m128i a,long long const * b,__m128i c,__m128i d)570 __m128i test_mm_mask_i64gather_epi64(__m128i a, long long const *b, __m128i c, __m128i d) {
571 // CHECK-LABEL: test_mm_mask_i64gather_epi64
572 // CHECK: call <2 x i64> @llvm.x86.avx2.gather.q.q(<2 x i64> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
573 return _mm_mask_i64gather_epi64(a, b, c, d, 2);
574 }
575
test_mm256_i64gather_epi64(long long const * b,__m256i c)576 __m256i test_mm256_i64gather_epi64(long long const *b, __m256i c) {
577 // CHECK-LABEL: test_mm256_i64gather_epi64
578 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.q.q.256(<4 x i64> zeroinitializer, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
579 return _mm256_i64gather_epi64(b, c, 2);
580 }
581
test_mm256_mask_i64gather_epi64(__m256i a,long long const * b,__m256i c,__m256i d)582 __m256i test_mm256_mask_i64gather_epi64(__m256i a, long long const *b, __m256i c, __m256i d) {
583 // CHECK-LABEL: test_mm256_mask_i64gather_epi64
584 // CHECK: call <4 x i64> @llvm.x86.avx2.gather.q.q.256(<4 x i64> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
585 return _mm256_mask_i64gather_epi64(a, b, c, d, 2);
586 }
587
test_mm_i64gather_pd(double const * b,__m128i c)588 __m128d test_mm_i64gather_pd(double const *b, __m128i c) {
589 // CHECK-LABEL: test_mm_i64gather_pd
590 // CHECK: [[CMP:%.*]] = fcmp oeq <2 x double>
591 // CHECK-NEXT: [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
592 // CHECK-NEXT: [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
593 // CHECK: call <2 x double> @llvm.x86.avx2.gather.q.pd(<2 x double> zeroinitializer, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}, i8 2)
594 return _mm_i64gather_pd(b, c, 2);
595 }
596
test_mm_mask_i64gather_pd(__m128d a,double const * b,__m128i c,__m128d d)597 __m128d test_mm_mask_i64gather_pd(__m128d a, double const *b, __m128i c, __m128d d) {
598 // CHECK-LABEL: test_mm_mask_i64gather_pd
599 // CHECK: call <2 x double> @llvm.x86.avx2.gather.q.pd(<2 x double> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}, i8 2)
600 return _mm_mask_i64gather_pd(a, b, c, d, 2);
601 }
602
test_mm256_i64gather_pd(double const * b,__m256i c)603 __m256d test_mm256_i64gather_pd(double const *b, __m256i c) {
604 // CHECK-LABEL: test_mm256_i64gather_pd
605 // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
606 // CHECK: call <4 x double> @llvm.x86.avx2.gather.q.pd.256(<4 x double> zeroinitializer, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}, i8 2)
607 return _mm256_i64gather_pd(b, c, 2);
608 }
609
test_mm256_mask_i64gather_pd(__m256d a,double const * b,__m256i c,__m256d d)610 __m256d test_mm256_mask_i64gather_pd(__m256d a, double const *b, __m256i c, __m256d d) {
611 // CHECK-LABEL: test_mm256_mask_i64gather_pd
612 // CHECK: call <4 x double> @llvm.x86.avx2.gather.q.pd.256(<4 x double> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}, i8 2)
613 return _mm256_mask_i64gather_pd(a, b, c, d, 2);
614 }
615
test_mm_i64gather_ps(float const * b,__m128i c)616 __m128 test_mm_i64gather_ps(float const *b, __m128i c) {
617 // CHECK-LABEL: test_mm_i64gather_ps
618 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x float>
619 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
620 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
621 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps(<4 x float> zeroinitializer, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
622 return _mm_i64gather_ps(b, c, 2);
623 }
624
test_mm_mask_i64gather_ps(__m128 a,float const * b,__m128i c,__m128 d)625 __m128 test_mm_mask_i64gather_ps(__m128 a, float const *b, __m128i c, __m128 d) {
626 // CHECK-LABEL: test_mm_mask_i64gather_ps
627 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps(<4 x float> %{{.*}}, i8* %{{.*}}, <2 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
628 return _mm_mask_i64gather_ps(a, b, c, d, 2);
629 }
630
test_mm256_i64gather_ps(float const * b,__m256i c)631 __m128 test_mm256_i64gather_ps(float const *b, __m256i c) {
632 // CHECK-LABEL: test_mm256_i64gather_ps
633 // CHECK: [[CMP:%.*]] = fcmp oeq <4 x float>
634 // CHECK-NEXT: [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
635 // CHECK-NEXT: [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
636 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps.256(<4 x float> zeroinitializer, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
637 return _mm256_i64gather_ps(b, c, 2);
638 }
639
test_mm256_mask_i64gather_ps(__m128 a,float const * b,__m256i c,__m128 d)640 __m128 test_mm256_mask_i64gather_ps(__m128 a, float const *b, __m256i c, __m128 d) {
641 // CHECK-LABEL: test_mm256_mask_i64gather_ps
642 // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps.256(<4 x float> %{{.*}}, i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
643 return _mm256_mask_i64gather_ps(a, b, c, d, 2);
644 }
645
test0_mm256_inserti128_si256(__m256i a,__m128i b)646 __m256i test0_mm256_inserti128_si256(__m256i a, __m128i b) {
647 // CHECK-LABEL: test0_mm256_inserti128_si256
648 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
649 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
650 return _mm256_inserti128_si256(a, b, 0);
651 }
652
test1_mm256_inserti128_si256(__m256i a,__m128i b)653 __m256i test1_mm256_inserti128_si256(__m256i a, __m128i b) {
654 // CHECK-LABEL: test1_mm256_inserti128_si256
655 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
656 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
657 return _mm256_inserti128_si256(a, b, 1);
658 }
659
660 // Immediate should be truncated to one bit.
test2_mm256_inserti128_si256(__m256i a,__m128i b)661 __m256i test2_mm256_inserti128_si256(__m256i a, __m128i b) {
662 // CHECK-LABEL: test2_mm256_inserti128_si256
663 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
664 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
665 return _mm256_inserti128_si256(a, b, 0);
666 }
667
test_mm256_madd_epi16(__m256i a,__m256i b)668 __m256i test_mm256_madd_epi16(__m256i a, __m256i b) {
669 // CHECK-LABEL: test_mm256_madd_epi16
670 // CHECK: call <8 x i32> @llvm.x86.avx2.pmadd.wd(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
671 return _mm256_madd_epi16(a, b);
672 }
673
test_mm256_maddubs_epi16(__m256i a,__m256i b)674 __m256i test_mm256_maddubs_epi16(__m256i a, __m256i b) {
675 // CHECK-LABEL: test_mm256_maddubs_epi16
676 // CHECK: call <16 x i16> @llvm.x86.avx2.pmadd.ub.sw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
677 return _mm256_maddubs_epi16(a, b);
678 }
679
test_mm_maskload_epi32(int const * a,__m128i m)680 __m128i test_mm_maskload_epi32(int const *a, __m128i m) {
681 // CHECK-LABEL: test_mm_maskload_epi32
682 // CHECK: call <4 x i32> @llvm.x86.avx2.maskload.d(i8* %{{.*}}, <4 x i32> %{{.*}})
683 return _mm_maskload_epi32(a, m);
684 }
685
test_mm256_maskload_epi32(int const * a,__m256i m)686 __m256i test_mm256_maskload_epi32(int const *a, __m256i m) {
687 // CHECK-LABEL: test_mm256_maskload_epi32
688 // CHECK: call <8 x i32> @llvm.x86.avx2.maskload.d.256(i8* %{{.*}}, <8 x i32> %{{.*}})
689 return _mm256_maskload_epi32(a, m);
690 }
691
test_mm_maskload_epi64(long long const * a,__m128i m)692 __m128i test_mm_maskload_epi64(long long const *a, __m128i m) {
693 // CHECK-LABEL: test_mm_maskload_epi64
694 // CHECK: call <2 x i64> @llvm.x86.avx2.maskload.q(i8* %{{.*}}, <2 x i64> %{{.*}})
695 return _mm_maskload_epi64(a, m);
696 }
697
test_mm256_maskload_epi64(long long const * a,__m256i m)698 __m256i test_mm256_maskload_epi64(long long const *a, __m256i m) {
699 // CHECK-LABEL: test_mm256_maskload_epi64
700 // CHECK: call <4 x i64> @llvm.x86.avx2.maskload.q.256(i8* %{{.*}}, <4 x i64> %{{.*}})
701 return _mm256_maskload_epi64(a, m);
702 }
703
test_mm_maskstore_epi32(int * a,__m128i m,__m128i b)704 void test_mm_maskstore_epi32(int *a, __m128i m, __m128i b) {
705 // CHECK-LABEL: test_mm_maskstore_epi32
706 // CHECK: call void @llvm.x86.avx2.maskstore.d(i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
707 _mm_maskstore_epi32(a, m, b);
708 }
709
test_mm256_maskstore_epi32(int * a,__m256i m,__m256i b)710 void test_mm256_maskstore_epi32(int *a, __m256i m, __m256i b) {
711 // CHECK-LABEL: test_mm256_maskstore_epi32
712 // CHECK: call void @llvm.x86.avx2.maskstore.d.256(i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
713 _mm256_maskstore_epi32(a, m, b);
714 }
715
test_mm_maskstore_epi64(long long * a,__m128i m,__m128i b)716 void test_mm_maskstore_epi64(long long *a, __m128i m, __m128i b) {
717 // CHECK-LABEL: test_mm_maskstore_epi64
718 // CHECK: call void @llvm.x86.avx2.maskstore.q(i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}})
719 _mm_maskstore_epi64(a, m, b);
720 }
721
test_mm256_maskstore_epi64(long long * a,__m256i m,__m256i b)722 void test_mm256_maskstore_epi64(long long *a, __m256i m, __m256i b) {
723 // CHECK-LABEL: test_mm256_maskstore_epi64
724 // CHECK: call void @llvm.x86.avx2.maskstore.q.256(i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}})
725 _mm256_maskstore_epi64(a, m, b);
726 }
727
test_mm256_max_epi8(__m256i a,__m256i b)728 __m256i test_mm256_max_epi8(__m256i a, __m256i b) {
729 // CHECK-LABEL: test_mm256_max_epi8
730 // CHECK: call <32 x i8> @llvm.smax.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
731 return _mm256_max_epi8(a, b);
732 }
733
test_mm256_max_epi16(__m256i a,__m256i b)734 __m256i test_mm256_max_epi16(__m256i a, __m256i b) {
735 // CHECK-LABEL: test_mm256_max_epi16
736 // CHECK: call <16 x i16> @llvm.smax.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
737 return _mm256_max_epi16(a, b);
738 }
739
test_mm256_max_epi32(__m256i a,__m256i b)740 __m256i test_mm256_max_epi32(__m256i a, __m256i b) {
741 // CHECK-LABEL: test_mm256_max_epi32
742 // CHECK: call <8 x i32> @llvm.smax.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
743 return _mm256_max_epi32(a, b);
744 }
745
test_mm256_max_epu8(__m256i a,__m256i b)746 __m256i test_mm256_max_epu8(__m256i a, __m256i b) {
747 // CHECK-LABEL: test_mm256_max_epu8
748 // CHECK: call <32 x i8> @llvm.umax.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
749 return _mm256_max_epu8(a, b);
750 }
751
test_mm256_max_epu16(__m256i a,__m256i b)752 __m256i test_mm256_max_epu16(__m256i a, __m256i b) {
753 // CHECK-LABEL: test_mm256_max_epu16
754 // CHECK: call <16 x i16> @llvm.umax.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
755 return _mm256_max_epu16(a, b);
756 }
757
test_mm256_max_epu32(__m256i a,__m256i b)758 __m256i test_mm256_max_epu32(__m256i a, __m256i b) {
759 // CHECK-LABEL: test_mm256_max_epu32
760 // CHECK: call <8 x i32> @llvm.umax.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
761 return _mm256_max_epu32(a, b);
762 }
763
test_mm256_min_epi8(__m256i a,__m256i b)764 __m256i test_mm256_min_epi8(__m256i a, __m256i b) {
765 // CHECK-LABEL: test_mm256_min_epi8
766 // CHECK: call <32 x i8> @llvm.smin.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
767 return _mm256_min_epi8(a, b);
768 }
769
test_mm256_min_epi16(__m256i a,__m256i b)770 __m256i test_mm256_min_epi16(__m256i a, __m256i b) {
771 // CHECK-LABEL: test_mm256_min_epi16
772 // CHECK: call <16 x i16> @llvm.smin.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
773 return _mm256_min_epi16(a, b);
774 }
775
test_mm256_min_epi32(__m256i a,__m256i b)776 __m256i test_mm256_min_epi32(__m256i a, __m256i b) {
777 // CHECK-LABEL: test_mm256_min_epi32
778 // CHECK: call <8 x i32> @llvm.smin.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
779 return _mm256_min_epi32(a, b);
780 }
781
test_mm256_min_epu8(__m256i a,__m256i b)782 __m256i test_mm256_min_epu8(__m256i a, __m256i b) {
783 // CHECK-LABEL: test_mm256_min_epu8
784 // CHECK: call <32 x i8> @llvm.umin.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
785 return _mm256_min_epu8(a, b);
786 }
787
test_mm256_min_epu16(__m256i a,__m256i b)788 __m256i test_mm256_min_epu16(__m256i a, __m256i b) {
789 // CHECK-LABEL: test_mm256_min_epu16
790 // CHECK: call <16 x i16> @llvm.umin.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
791 return _mm256_min_epu16(a, b);
792 }
793
test_mm256_min_epu32(__m256i a,__m256i b)794 __m256i test_mm256_min_epu32(__m256i a, __m256i b) {
795 // CHECK-LABEL: test_mm256_min_epu32
796 // CHECK: call <8 x i32> @llvm.umin.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
797 return _mm256_min_epu32(a, b);
798 }
799
test_mm256_movemask_epi8(__m256i a)800 int test_mm256_movemask_epi8(__m256i a) {
801 // CHECK-LABEL: test_mm256_movemask_epi8
802 // CHECK: call i32 @llvm.x86.avx2.pmovmskb(<32 x i8> %{{.*}})
803 return _mm256_movemask_epi8(a);
804 }
805
test_mm256_mpsadbw_epu8(__m256i x,__m256i y)806 __m256i test_mm256_mpsadbw_epu8(__m256i x, __m256i y) {
807 // CHECK-LABEL: test_mm256_mpsadbw_epu8
808 // CHECK: call <16 x i16> @llvm.x86.avx2.mpsadbw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}, i8 3)
809 return _mm256_mpsadbw_epu8(x, y, 3);
810 }
811
test_mm256_mul_epi32(__m256i a,__m256i b)812 __m256i test_mm256_mul_epi32(__m256i a, __m256i b) {
813 // CHECK-LABEL: test_mm256_mul_epi32
814 // CHECK: shl <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
815 // CHECK: ashr <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
816 // CHECK: shl <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
817 // CHECK: ashr <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
818 // CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
819 return _mm256_mul_epi32(a, b);
820 }
821
test_mm256_mul_epu32(__m256i a,__m256i b)822 __m256i test_mm256_mul_epu32(__m256i a, __m256i b) {
823 // CHECK-LABEL: test_mm256_mul_epu32
824 // CHECK: and <4 x i64> %{{.*}}, <i64 4294967295, i64 4294967295, i64 4294967295, i64 4294967295>
825 // CHECK: and <4 x i64> %{{.*}}, <i64 4294967295, i64 4294967295, i64 4294967295, i64 4294967295>
826 // CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
827 return _mm256_mul_epu32(a, b);
828 }
829
test_mm256_mulhi_epu16(__m256i a,__m256i b)830 __m256i test_mm256_mulhi_epu16(__m256i a, __m256i b) {
831 // CHECK-LABEL: test_mm256_mulhi_epu16
832 // CHECK: call <16 x i16> @llvm.x86.avx2.pmulhu.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
833 return _mm256_mulhi_epu16(a, b);
834 }
835
test_mm256_mulhi_epi16(__m256i a,__m256i b)836 __m256i test_mm256_mulhi_epi16(__m256i a, __m256i b) {
837 // CHECK-LABEL: test_mm256_mulhi_epi16
838 // CHECK: call <16 x i16> @llvm.x86.avx2.pmulh.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
839 return _mm256_mulhi_epi16(a, b);
840 }
841
test_mm256_mulhrs_epi16(__m256i a,__m256i b)842 __m256i test_mm256_mulhrs_epi16(__m256i a, __m256i b) {
843 // CHECK-LABEL: test_mm256_mulhrs_epi16
844 // CHECK: call <16 x i16> @llvm.x86.avx2.pmul.hr.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
845 return _mm256_mulhrs_epi16(a, b);
846 }
847
test_mm256_mullo_epi16(__m256i a,__m256i b)848 __m256i test_mm256_mullo_epi16(__m256i a, __m256i b) {
849 // CHECK-LABEL: test_mm256_mullo_epi16
850 // CHECK: mul <16 x i16>
851 return _mm256_mullo_epi16(a, b);
852 }
853
test_mm256_mullo_epi32(__m256i a,__m256i b)854 __m256i test_mm256_mullo_epi32(__m256i a, __m256i b) {
855 // CHECK-LABEL: test_mm256_mullo_epi32
856 // CHECK: mul <8 x i32>
857 return _mm256_mullo_epi32(a, b);
858 }
859
test_mm256_or_si256(__m256i a,__m256i b)860 __m256i test_mm256_or_si256(__m256i a, __m256i b) {
861 // CHECK-LABEL: test_mm256_or_si256
862 // CHECK: or <4 x i64>
863 return _mm256_or_si256(a, b);
864 }
865
test_mm256_packs_epi16(__m256i a,__m256i b)866 __m256i test_mm256_packs_epi16(__m256i a, __m256i b) {
867 // CHECK-LABEL: test_mm256_packs_epi16
868 // CHECK: call <32 x i8> @llvm.x86.avx2.packsswb(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
869 return _mm256_packs_epi16(a, b);
870 }
871
test_mm256_packs_epi32(__m256i a,__m256i b)872 __m256i test_mm256_packs_epi32(__m256i a, __m256i b) {
873 // CHECK-LABEL: test_mm256_packs_epi32
874 // CHECK: call <16 x i16> @llvm.x86.avx2.packssdw(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
875 return _mm256_packs_epi32(a, b);
876 }
877
test_mm256_packs_epu16(__m256i a,__m256i b)878 __m256i test_mm256_packs_epu16(__m256i a, __m256i b) {
879 // CHECK-LABEL: test_mm256_packs_epu16
880 // CHECK: call <32 x i8> @llvm.x86.avx2.packuswb(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
881 return _mm256_packus_epi16(a, b);
882 }
883
test_mm256_packs_epu32(__m256i a,__m256i b)884 __m256i test_mm256_packs_epu32(__m256i a, __m256i b) {
885 // CHECK-LABEL: test_mm256_packs_epu32
886 // CHECK: call <16 x i16> @llvm.x86.avx2.packusdw(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
887 return _mm256_packus_epi32(a, b);
888 }
889
test_mm256_permute2x128_si256(__m256i a,__m256i b)890 __m256i test_mm256_permute2x128_si256(__m256i a, __m256i b) {
891 // CHECK-LABEL: test_mm256_permute2x128_si256
892 // CHECK: shufflevector <4 x i64> zeroinitializer, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
893 return _mm256_permute2x128_si256(a, b, 0x38);
894 }
895
test_mm256_permute4x64_epi64(__m256i a)896 __m256i test_mm256_permute4x64_epi64(__m256i a) {
897 // CHECK-LABEL: test_mm256_permute4x64_epi64
898 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <4 x i32> <i32 3, i32 0, i32 2, i32 0>
899 return _mm256_permute4x64_epi64(a, 35);
900 }
901
test_mm256_permute4x64_pd(__m256d a)902 __m256d test_mm256_permute4x64_pd(__m256d a) {
903 // CHECK-LABEL: test_mm256_permute4x64_pd
904 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <4 x i32> <i32 1, i32 2, i32 1, i32 0>
905 return _mm256_permute4x64_pd(a, 25);
906 }
907
test_mm256_permutevar8x32_epi32(__m256i a,__m256i b)908 __m256i test_mm256_permutevar8x32_epi32(__m256i a, __m256i b) {
909 // CHECK-LABEL: test_mm256_permutevar8x32_epi32
910 // CHECK: call <8 x i32> @llvm.x86.avx2.permd(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
911 return _mm256_permutevar8x32_epi32(a, b);
912 }
913
test_mm256_permutevar8x32_ps(__m256 a,__m256i b)914 __m256 test_mm256_permutevar8x32_ps(__m256 a, __m256i b) {
915 // CHECK-LABEL: test_mm256_permutevar8x32_ps
916 // CHECK: call <8 x float> @llvm.x86.avx2.permps(<8 x float> %{{.*}}, <8 x i32> %{{.*}})
917 return _mm256_permutevar8x32_ps(a, b);
918 }
919
test_mm256_sad_epu8(__m256i x,__m256i y)920 __m256i test_mm256_sad_epu8(__m256i x, __m256i y) {
921 // CHECK-LABEL: test_mm256_sad_epu8
922 // CHECK: call <4 x i64> @llvm.x86.avx2.psad.bw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
923 return _mm256_sad_epu8(x, y);
924 }
925
test_mm256_shuffle_epi8(__m256i a,__m256i b)926 __m256i test_mm256_shuffle_epi8(__m256i a, __m256i b) {
927 // CHECK-LABEL: test_mm256_shuffle_epi8
928 // CHECK: call <32 x i8> @llvm.x86.avx2.pshuf.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
929 return _mm256_shuffle_epi8(a, b);
930 }
931
test_mm256_shuffle_epi32(__m256i a)932 __m256i test_mm256_shuffle_epi32(__m256i a) {
933 // CHECK-LABEL: test_mm256_shuffle_epi32
934 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> undef, <8 x i32> <i32 3, i32 3, i32 0, i32 0, i32 7, i32 7, i32 4, i32 4>
935 return _mm256_shuffle_epi32(a, 15);
936 }
937
test_mm256_shufflehi_epi16(__m256i a)938 __m256i test_mm256_shufflehi_epi16(__m256i a) {
939 // CHECK-LABEL: test_mm256_shufflehi_epi16
940 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> undef, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 7, i32 6, i32 6, i32 5, i32 8, i32 9, i32 10, i32 11, i32 15, i32 14, i32 14, i32 13>
941 return _mm256_shufflehi_epi16(a, 107);
942 }
943
test_mm256_shufflelo_epi16(__m256i a)944 __m256i test_mm256_shufflelo_epi16(__m256i a) {
945 // CHECK-LABEL: test_mm256_shufflelo_epi16
946 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> undef, <16 x i32> <i32 3, i32 0, i32 1, i32 1, i32 4, i32 5, i32 6, i32 7, i32 11, i32 8, i32 9, i32 9, i32 12, i32 13, i32 14, i32 15>
947 return _mm256_shufflelo_epi16(a, 83);
948 }
949
test_mm256_sign_epi8(__m256i a,__m256i b)950 __m256i test_mm256_sign_epi8(__m256i a, __m256i b) {
951 // CHECK-LABEL: test_mm256_sign_epi8
952 // CHECK: call <32 x i8> @llvm.x86.avx2.psign.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
953 return _mm256_sign_epi8(a, b);
954 }
955
test_mm256_sign_epi16(__m256i a,__m256i b)956 __m256i test_mm256_sign_epi16(__m256i a, __m256i b) {
957 // CHECK-LABEL: test_mm256_sign_epi16
958 // CHECK: call <16 x i16> @llvm.x86.avx2.psign.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
959 return _mm256_sign_epi16(a, b);
960 }
961
test_mm256_sign_epi32(__m256i a,__m256i b)962 __m256i test_mm256_sign_epi32(__m256i a, __m256i b) {
963 // CHECK-LABEL: test_mm256_sign_epi32
964 // CHECK: call <8 x i32> @llvm.x86.avx2.psign.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
965 return _mm256_sign_epi32(a, b);
966 }
967
test_mm256_slli_epi16(__m256i a)968 __m256i test_mm256_slli_epi16(__m256i a) {
969 // CHECK-LABEL: test_mm256_slli_epi16
970 // CHECK: call <16 x i16> @llvm.x86.avx2.pslli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
971 return _mm256_slli_epi16(a, 3);
972 }
973
test_mm256_slli_epi16_2(__m256i a,int b)974 __m256i test_mm256_slli_epi16_2(__m256i a, int b) {
975 // CHECK-LABEL: test_mm256_slli_epi16_2
976 // CHECK: call <16 x i16> @llvm.x86.avx2.pslli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
977 return _mm256_slli_epi16(a, b);
978 }
979
test_mm256_slli_epi32(__m256i a)980 __m256i test_mm256_slli_epi32(__m256i a) {
981 // CHECK-LABEL: test_mm256_slli_epi32
982 // CHECK: call <8 x i32> @llvm.x86.avx2.pslli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
983 return _mm256_slli_epi32(a, 3);
984 }
985
test_mm256_slli_epi32_2(__m256i a,int b)986 __m256i test_mm256_slli_epi32_2(__m256i a, int b) {
987 // CHECK-LABEL: test_mm256_slli_epi32_2
988 // CHECK: call <8 x i32> @llvm.x86.avx2.pslli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
989 return _mm256_slli_epi32(a, b);
990 }
991
test_mm256_slli_epi64(__m256i a)992 __m256i test_mm256_slli_epi64(__m256i a) {
993 // CHECK-LABEL: test_mm256_slli_epi64
994 // CHECK: call <4 x i64> @llvm.x86.avx2.pslli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
995 return _mm256_slli_epi64(a, 3);
996 }
997
test_mm256_slli_epi64_2(__m256i a,int b)998 __m256i test_mm256_slli_epi64_2(__m256i a, int b) {
999 // CHECK-LABEL: test_mm256_slli_epi64_2
1000 // CHECK: call <4 x i64> @llvm.x86.avx2.pslli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
1001 return _mm256_slli_epi64(a, b);
1002 }
1003
test_mm256_slli_si256(__m256i a)1004 __m256i test_mm256_slli_si256(__m256i a) {
1005 // CHECK-LABEL: test_mm256_slli_si256
1006 // CHECK: shufflevector <32 x i8> zeroinitializer, <32 x i8> %{{.*}}, <32 x i32> <i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60>
1007 return _mm256_slli_si256(a, 3);
1008 }
1009
test_mm_sllv_epi32(__m128i a,__m128i b)1010 __m128i test_mm_sllv_epi32(__m128i a, __m128i b) {
1011 // CHECK-LABEL: test_mm_sllv_epi32
1012 // CHECK: call <4 x i32> @llvm.x86.avx2.psllv.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1013 return _mm_sllv_epi32(a, b);
1014 }
1015
test_mm256_sllv_epi32(__m256i a,__m256i b)1016 __m256i test_mm256_sllv_epi32(__m256i a, __m256i b) {
1017 // CHECK-LABEL: test_mm256_sllv_epi32
1018 // CHECK: call <8 x i32> @llvm.x86.avx2.psllv.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
1019 return _mm256_sllv_epi32(a, b);
1020 }
1021
test_mm_sllv_epi64(__m128i a,__m128i b)1022 __m128i test_mm_sllv_epi64(__m128i a, __m128i b) {
1023 // CHECK-LABEL: test_mm_sllv_epi64
1024 // CHECK: call <2 x i64> @llvm.x86.avx2.psllv.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1025 return _mm_sllv_epi64(a, b);
1026 }
1027
test_mm256_sllv_epi64(__m256i a,__m256i b)1028 __m256i test_mm256_sllv_epi64(__m256i a, __m256i b) {
1029 // CHECK-LABEL: test_mm256_sllv_epi64
1030 // CHECK: call <4 x i64> @llvm.x86.avx2.psllv.q.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
1031 return _mm256_sllv_epi64(a, b);
1032 }
1033
test_mm256_sra_epi16(__m256i a,__m128i b)1034 __m256i test_mm256_sra_epi16(__m256i a, __m128i b) {
1035 // CHECK-LABEL: test_mm256_sra_epi16
1036 // CHECK: call <16 x i16> @llvm.x86.avx2.psra.w(<16 x i16> %{{.*}}, <8 x i16> %{{.*}})
1037 return _mm256_sra_epi16(a, b);
1038 }
1039
test_mm256_sra_epi32(__m256i a,__m128i b)1040 __m256i test_mm256_sra_epi32(__m256i a, __m128i b) {
1041 // CHECK-LABEL: test_mm256_sra_epi32
1042 // CHECK: call <8 x i32> @llvm.x86.avx2.psra.d(<8 x i32> %{{.*}}, <4 x i32> %{{.*}})
1043 return _mm256_sra_epi32(a, b);
1044 }
1045
test_mm256_srai_epi16(__m256i a)1046 __m256i test_mm256_srai_epi16(__m256i a) {
1047 // CHECK-LABEL: test_mm256_srai_epi16
1048 // CHECK: call <16 x i16> @llvm.x86.avx2.psrai.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1049 return _mm256_srai_epi16(a, 3);
1050 }
1051
test_mm256_srai_epi16_2(__m256i a,int b)1052 __m256i test_mm256_srai_epi16_2(__m256i a, int b) {
1053 // CHECK-LABEL: test_mm256_srai_epi16_2
1054 // CHECK: call <16 x i16> @llvm.x86.avx2.psrai.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1055 return _mm256_srai_epi16(a, b);
1056 }
1057
test_mm256_srai_epi32(__m256i a)1058 __m256i test_mm256_srai_epi32(__m256i a) {
1059 // CHECK-LABEL: test_mm256_srai_epi32
1060 // CHECK: call <8 x i32> @llvm.x86.avx2.psrai.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1061 return _mm256_srai_epi32(a, 3);
1062 }
1063
test_mm256_srai_epi32_2(__m256i a,int b)1064 __m256i test_mm256_srai_epi32_2(__m256i a, int b) {
1065 // CHECK-LABEL: test_mm256_srai_epi32_2
1066 // CHECK: call <8 x i32> @llvm.x86.avx2.psrai.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1067 return _mm256_srai_epi32(a, b);
1068 }
1069
test_mm_srav_epi32(__m128i a,__m128i b)1070 __m128i test_mm_srav_epi32(__m128i a, __m128i b) {
1071 // CHECK-LABEL: test_mm_srav_epi32
1072 // CHECK: call <4 x i32> @llvm.x86.avx2.psrav.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1073 return _mm_srav_epi32(a, b);
1074 }
1075
test_mm256_srav_epi32(__m256i a,__m256i b)1076 __m256i test_mm256_srav_epi32(__m256i a, __m256i b) {
1077 // CHECK-LABEL: test_mm256_srav_epi32
1078 // CHECK: call <8 x i32> @llvm.x86.avx2.psrav.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
1079 return _mm256_srav_epi32(a, b);
1080 }
1081
test_mm256_srl_epi16(__m256i a,__m128i b)1082 __m256i test_mm256_srl_epi16(__m256i a, __m128i b) {
1083 // CHECK-LABEL: test_mm256_srl_epi16
1084 // CHECK: call <16 x i16> @llvm.x86.avx2.psrl.w(<16 x i16> %{{.*}}, <8 x i16> %{{.*}})
1085 return _mm256_srl_epi16(a, b);
1086 }
1087
test_mm256_srl_epi32(__m256i a,__m128i b)1088 __m256i test_mm256_srl_epi32(__m256i a, __m128i b) {
1089 // CHECK-LABEL: test_mm256_srl_epi32
1090 // CHECK:call <8 x i32> @llvm.x86.avx2.psrl.d(<8 x i32> %{{.*}}, <4 x i32> %{{.*}})
1091 return _mm256_srl_epi32(a, b);
1092 }
1093
test_mm256_srl_epi64(__m256i a,__m128i b)1094 __m256i test_mm256_srl_epi64(__m256i a, __m128i b) {
1095 // CHECK-LABEL: test_mm256_srl_epi64
1096 // CHECK: call <4 x i64> @llvm.x86.avx2.psrl.q(<4 x i64> %{{.*}}, <2 x i64> %{{.*}})
1097 return _mm256_srl_epi64(a, b);
1098 }
1099
test_mm256_srli_epi16(__m256i a)1100 __m256i test_mm256_srli_epi16(__m256i a) {
1101 // CHECK-LABEL: test_mm256_srli_epi16
1102 // CHECK: call <16 x i16> @llvm.x86.avx2.psrli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1103 return _mm256_srli_epi16(a, 3);
1104 }
1105
test_mm256_srli_epi16_2(__m256i a,int b)1106 __m256i test_mm256_srli_epi16_2(__m256i a, int b) {
1107 // CHECK-LABEL: test_mm256_srli_epi16_2
1108 // CHECK: call <16 x i16> @llvm.x86.avx2.psrli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1109 return _mm256_srli_epi16(a, b);
1110 }
1111
test_mm256_srli_epi32(__m256i a)1112 __m256i test_mm256_srli_epi32(__m256i a) {
1113 // CHECK-LABEL: test_mm256_srli_epi32
1114 // CHECK: call <8 x i32> @llvm.x86.avx2.psrli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1115 return _mm256_srli_epi32(a, 3);
1116 }
1117
test_mm256_srli_epi32_2(__m256i a,int b)1118 __m256i test_mm256_srli_epi32_2(__m256i a, int b) {
1119 // CHECK-LABEL: test_mm256_srli_epi32_2
1120 // CHECK: call <8 x i32> @llvm.x86.avx2.psrli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1121 return _mm256_srli_epi32(a, b);
1122 }
1123
test_mm256_srli_epi64(__m256i a)1124 __m256i test_mm256_srli_epi64(__m256i a) {
1125 // CHECK-LABEL: test_mm256_srli_epi64
1126 // CHECK: call <4 x i64> @llvm.x86.avx2.psrli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
1127 return _mm256_srli_epi64(a, 3);
1128 }
1129
test_mm256_srli_epi64_2(__m256i a,int b)1130 __m256i test_mm256_srli_epi64_2(__m256i a, int b) {
1131 // CHECK-LABEL: test_mm256_srli_epi64_2
1132 // CHECK: call <4 x i64> @llvm.x86.avx2.psrli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
1133 return _mm256_srli_epi64(a, b);
1134 }
1135
test_mm256_srli_si256(__m256i a)1136 __m256i test_mm256_srli_si256(__m256i a) {
1137 // CHECK-LABEL: test_mm256_srli_si256
1138 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> zeroinitializer, <32 x i32> <i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 32, i32 33, i32 34, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 48, i32 49, i32 50>
1139 return _mm256_srli_si256(a, 3);
1140 }
1141
test_mm_srlv_epi32(__m128i a,__m128i b)1142 __m128i test_mm_srlv_epi32(__m128i a, __m128i b) {
1143 // CHECK-LABEL: test_mm_srlv_epi32
1144 // CHECK: call <4 x i32> @llvm.x86.avx2.psrlv.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1145 return _mm_srlv_epi32(a, b);
1146 }
1147
test_mm256_srlv_epi32(__m256i a,__m256i b)1148 __m256i test_mm256_srlv_epi32(__m256i a, __m256i b) {
1149 // CHECK-LABEL: test_mm256_srlv_epi32
1150 // CHECK: call <8 x i32> @llvm.x86.avx2.psrlv.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
1151 return _mm256_srlv_epi32(a, b);
1152 }
1153
test_mm_srlv_epi64(__m128i a,__m128i b)1154 __m128i test_mm_srlv_epi64(__m128i a, __m128i b) {
1155 // CHECK-LABEL: test_mm_srlv_epi64
1156 // CHECK: call <2 x i64> @llvm.x86.avx2.psrlv.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1157 return _mm_srlv_epi64(a, b);
1158 }
1159
test_mm256_srlv_epi64(__m256i a,__m256i b)1160 __m256i test_mm256_srlv_epi64(__m256i a, __m256i b) {
1161 // CHECK-LABEL: test_mm256_srlv_epi64
1162 // CHECK: call <4 x i64> @llvm.x86.avx2.psrlv.q.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
1163 return _mm256_srlv_epi64(a, b);
1164 }
1165
test_mm256_stream_load_si256(__m256i const * a)1166 __m256i test_mm256_stream_load_si256(__m256i const *a) {
1167 // CHECK-LABEL: test_mm256_stream_load_si256
1168 // CHECK: load <4 x i64>, <4 x i64>* %{{.*}}, align 32, !nontemporal
1169 return _mm256_stream_load_si256(a);
1170 }
1171
test_mm256_sub_epi8(__m256i a,__m256i b)1172 __m256i test_mm256_sub_epi8(__m256i a, __m256i b) {
1173 // CHECK-LABEL: test_mm256_sub_epi8
1174 // CHECK: sub <32 x i8>
1175 return _mm256_sub_epi8(a, b);
1176 }
1177
test_mm256_sub_epi16(__m256i a,__m256i b)1178 __m256i test_mm256_sub_epi16(__m256i a, __m256i b) {
1179 // CHECK-LABEL: test_mm256_sub_epi16
1180 // CHECK: sub <16 x i16>
1181 return _mm256_sub_epi16(a, b);
1182 }
1183
test_mm256_sub_epi32(__m256i a,__m256i b)1184 __m256i test_mm256_sub_epi32(__m256i a, __m256i b) {
1185 // CHECK-LABEL: test_mm256_sub_epi32
1186 // CHECK: sub <8 x i32>
1187 return _mm256_sub_epi32(a, b);
1188 }
1189
test_mm256_sub_epi64(__m256i a,__m256i b)1190 __m256i test_mm256_sub_epi64(__m256i a, __m256i b) {
1191 // CHECK-LABEL: test_mm256_sub_epi64
1192 // CHECK: sub <4 x i64>
1193 return _mm256_sub_epi64(a, b);
1194 }
1195
test_mm256_subs_epi8(__m256i a,__m256i b)1196 __m256i test_mm256_subs_epi8(__m256i a, __m256i b) {
1197 // CHECK-LABEL: test_mm256_subs_epi8
1198 // CHECK: call <32 x i8> @llvm.ssub.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
1199 return _mm256_subs_epi8(a, b);
1200 }
1201
test_mm256_subs_epi16(__m256i a,__m256i b)1202 __m256i test_mm256_subs_epi16(__m256i a, __m256i b) {
1203 // CHECK-LABEL: test_mm256_subs_epi16
1204 // CHECK: call <16 x i16> @llvm.ssub.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
1205 return _mm256_subs_epi16(a, b);
1206 }
1207
test_mm256_subs_epu8(__m256i a,__m256i b)1208 __m256i test_mm256_subs_epu8(__m256i a, __m256i b) {
1209 // CHECK-LABEL: test_mm256_subs_epu8
1210 // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.psubus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
1211 // CHECK: call <32 x i8> @llvm.usub.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
1212 return _mm256_subs_epu8(a, b);
1213 }
1214
test_mm256_subs_epu16(__m256i a,__m256i b)1215 __m256i test_mm256_subs_epu16(__m256i a, __m256i b) {
1216 // CHECK-LABEL: test_mm256_subs_epu16
1217 // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.psubus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
1218 // CHECK: call <16 x i16> @llvm.usub.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
1219 return _mm256_subs_epu16(a, b);
1220 }
1221
test_mm256_unpackhi_epi8(__m256i a,__m256i b)1222 __m256i test_mm256_unpackhi_epi8(__m256i a, __m256i b) {
1223 // CHECK-LABEL: test_mm256_unpackhi_epi8
1224 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 8, i32 40, i32 9, i32 41, i32 10, i32 42, i32 11, i32 43, i32 12, i32 44, i32 13, i32 45, i32 14, i32 46, i32 15, i32 47, i32 24, i32 56, i32 25, i32 57, i32 26, i32 58, i32 27, i32 59, i32 28, i32 60, i32 29, i32 61, i32 30, i32 62, i32 31, i32 63>
1225 return _mm256_unpackhi_epi8(a, b);
1226 }
1227
test_mm256_unpackhi_epi16(__m256i a,__m256i b)1228 __m256i test_mm256_unpackhi_epi16(__m256i a, __m256i b) {
1229 // CHECK-LABEL: test_mm256_unpackhi_epi16
1230 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1231 return _mm256_unpackhi_epi16(a, b);
1232 }
1233
test_mm256_unpackhi_epi32(__m256i a,__m256i b)1234 __m256i test_mm256_unpackhi_epi32(__m256i a, __m256i b) {
1235 // CHECK-LABEL: test_mm256_unpackhi_epi32
1236 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 2, i32 10, i32 3, i32 11, i32 6, i32 14, i32 7, i32 15>
1237 return _mm256_unpackhi_epi32(a, b);
1238 }
1239
test_mm256_unpackhi_epi64(__m256i a,__m256i b)1240 __m256i test_mm256_unpackhi_epi64(__m256i a, __m256i b) {
1241 // CHECK-LABEL: test_mm256_unpackhi_epi64
1242 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1243 return _mm256_unpackhi_epi64(a, b);
1244 }
1245
test_mm256_unpacklo_epi8(__m256i a,__m256i b)1246 __m256i test_mm256_unpacklo_epi8(__m256i a, __m256i b) {
1247 // CHECK-LABEL: test_mm256_unpacklo_epi8
1248 // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 0, i32 32, i32 1, i32 33, i32 2, i32 34, i32 3, i32 35, i32 4, i32 36, i32 5, i32 37, i32 6, i32 38, i32 7, i32 39, i32 16, i32 48, i32 17, i32 49, i32 18, i32 50, i32 19, i32 51, i32 20, i32 52, i32 21, i32 53, i32 22, i32 54, i32 23, i32 55>
1249 return _mm256_unpacklo_epi8(a, b);
1250 }
1251
test_mm256_unpacklo_epi16(__m256i a,__m256i b)1252 __m256i test_mm256_unpacklo_epi16(__m256i a, __m256i b) {
1253 // CHECK-LABEL: test_mm256_unpacklo_epi16
1254 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27>
1255 return _mm256_unpacklo_epi16(a, b);
1256 }
1257
test_mm256_unpacklo_epi32(__m256i a,__m256i b)1258 __m256i test_mm256_unpacklo_epi32(__m256i a, __m256i b) {
1259 // CHECK-LABEL: test_mm256_unpacklo_epi32
1260 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 4, i32 12, i32 5, i32 13>
1261 return _mm256_unpacklo_epi32(a, b);
1262 }
1263
test_mm256_unpacklo_epi64(__m256i a,__m256i b)1264 __m256i test_mm256_unpacklo_epi64(__m256i a, __m256i b) {
1265 // CHECK-LABEL: test_mm256_unpacklo_epi64
1266 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1267 return _mm256_unpacklo_epi64(a, b);
1268 }
1269
test_mm256_xor_si256(__m256i a,__m256i b)1270 __m256i test_mm256_xor_si256(__m256i a, __m256i b) {
1271 // CHECK-LABEL: test_mm256_xor_si256
1272 // CHECK: xor <4 x i64>
1273 return _mm256_xor_si256(a, b);
1274 }
1275