Clang Project

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