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