1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s
2 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
3 // RUN: %clang_cc1 -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s
4 
5 
6 #include <immintrin.h>
7 
8 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll
9 
test_mm256_add_pd(__m256d A,__m256d B)10 __m256d test_mm256_add_pd(__m256d A, __m256d B) {
11   // CHECK-LABEL: test_mm256_add_pd
12   // CHECK: fadd <4 x double>
13   return _mm256_add_pd(A, B);
14 }
15 
test_mm256_add_ps(__m256 A,__m256 B)16 __m256 test_mm256_add_ps(__m256 A, __m256 B) {
17   // CHECK-LABEL: test_mm256_add_ps
18   // CHECK: fadd <8 x float>
19   return _mm256_add_ps(A, B);
20 }
21 
test_mm256_addsub_pd(__m256d A,__m256d B)22 __m256d test_mm256_addsub_pd(__m256d A, __m256d B) {
23   // CHECK-LABEL: test_mm256_addsub_pd
24   // CHECK: call <4 x double> @llvm.x86.avx.addsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
25   return _mm256_addsub_pd(A, B);
26 }
27 
test_mm256_addsub_ps(__m256 A,__m256 B)28 __m256 test_mm256_addsub_ps(__m256 A, __m256 B) {
29   // CHECK-LABEL: test_mm256_addsub_ps
30   // CHECK: call <8 x float> @llvm.x86.avx.addsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
31   return _mm256_addsub_ps(A, B);
32 }
33 
test_mm256_and_pd(__m256d A,__m256d B)34 __m256d test_mm256_and_pd(__m256d A, __m256d B) {
35   // CHECK-LABEL: test_mm256_and_pd
36   // CHECK: and <4 x i64>
37   return _mm256_and_pd(A, B);
38 }
39 
test_mm256_and_ps(__m256 A,__m256 B)40 __m256 test_mm256_and_ps(__m256 A, __m256 B) {
41   // CHECK-LABEL: test_mm256_and_ps
42   // CHECK: and <8 x i32>
43   return _mm256_and_ps(A, B);
44 }
45 
test_mm256_andnot_pd(__m256d A,__m256d B)46 __m256d test_mm256_andnot_pd(__m256d A, __m256d B) {
47   // CHECK-LABEL: test_mm256_andnot_pd
48   // CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1>
49   // CHECK: and <4 x i64>
50   return _mm256_andnot_pd(A, B);
51 }
52 
test_mm256_andnot_ps(__m256 A,__m256 B)53 __m256 test_mm256_andnot_ps(__m256 A, __m256 B) {
54   // CHECK-LABEL: test_mm256_andnot_ps
55   // CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
56   // CHECK: and <8 x i32>
57   return _mm256_andnot_ps(A, B);
58 }
59 
test_mm256_blend_pd(__m256d A,__m256d B)60 __m256d test_mm256_blend_pd(__m256d A, __m256d B) {
61   // CHECK-LABEL: test_mm256_blend_pd
62   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3>
63   return _mm256_blend_pd(A, B, 0x05);
64 }
65 
test_mm256_blend_ps(__m256 A,__m256 B)66 __m256 test_mm256_blend_ps(__m256 A, __m256 B) {
67   // CHECK-LABEL: test_mm256_blend_ps
68   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 8, i32 1, i32 10, i32 3, i32 12, i32 13, i32 6, i32 7>
69   return _mm256_blend_ps(A, B, 0x35);
70 }
71 
test_mm256_blendv_pd(__m256d V1,__m256d V2,__m256d V3)72 __m256d test_mm256_blendv_pd(__m256d V1, __m256d V2, __m256d V3) {
73   // CHECK-LABEL: test_mm256_blendv_pd
74   // CHECK: call <4 x double> @llvm.x86.avx.blendv.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}})
75   return _mm256_blendv_pd(V1, V2, V3);
76 }
77 
test_mm256_blendv_ps(__m256 V1,__m256 V2,__m256 V3)78 __m256 test_mm256_blendv_ps(__m256 V1, __m256 V2, __m256 V3) {
79   // CHECK-LABEL: test_mm256_blendv_ps
80   // CHECK: call <8 x float> @llvm.x86.avx.blendv.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}})
81   return _mm256_blendv_ps(V1, V2, V3);
82 }
83 
test_mm256_broadcast_pd(__m128d * A)84 __m256d test_mm256_broadcast_pd(__m128d* A) {
85   // CHECK-LABEL: test_mm256_broadcast_pd
86   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
87   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
88   return _mm256_broadcast_pd(A);
89 }
90 
test_mm256_broadcast_ps(__m128 * A)91 __m256 test_mm256_broadcast_ps(__m128* A) {
92   // CHECK-LABEL: test_mm256_broadcast_ps
93   // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
94   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3>
95   return _mm256_broadcast_ps(A);
96 }
97 
test_mm256_broadcast_sd(double * A)98 __m256d test_mm256_broadcast_sd(double* A) {
99   // CHECK-LABEL: test_mm256_broadcast_sd
100   // CHECK: load double, double* %{{.*}}
101   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
102   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
103   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
104   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
105   return _mm256_broadcast_sd(A);
106 }
107 
test_mm_broadcast_ss(float * A)108 __m128 test_mm_broadcast_ss(float* A) {
109   // CHECK-LABEL: test_mm_broadcast_ss
110   // CHECK: load float, float* %{{.*}}
111   // CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 0
112   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 1
113   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 2
114   // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 3
115   return _mm_broadcast_ss(A);
116 }
117 
test_mm256_broadcast_ss(float * A)118 __m256 test_mm256_broadcast_ss(float* A) {
119   // CHECK-LABEL: test_mm256_broadcast_ss
120   // CHECK: load float, float* %{{.*}}
121   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
122   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
123   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
124   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
125   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
126   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
127   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
128   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
129   return _mm256_broadcast_ss(A);
130 }
131 
test_mm256_castpd_ps(__m256d A)132 __m256 test_mm256_castpd_ps(__m256d A) {
133   // CHECK-LABEL: test_mm256_castpd_ps
134   // CHECK: bitcast <4 x double> %{{.*}} to <8 x float>
135   return _mm256_castpd_ps(A);
136 }
137 
test_mm256_castpd_si256(__m256d A)138 __m256i test_mm256_castpd_si256(__m256d A) {
139   // CHECK-LABEL: test_mm256_castpd_si256
140   // CHECK: bitcast <4 x double> %{{.*}} to <4 x i64>
141   return _mm256_castpd_si256(A);
142 }
143 
test_mm256_castpd128_pd256(__m128d A)144 __m256d test_mm256_castpd128_pd256(__m128d A) {
145   // CHECK-LABEL: test_mm256_castpd128_pd256
146   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
147   return _mm256_castpd128_pd256(A);
148 }
149 
test_mm256_castpd256_pd128(__m256d A)150 __m128d test_mm256_castpd256_pd128(__m256d A) {
151   // CHECK-LABEL: test_mm256_castpd256_pd128
152   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1>
153   return _mm256_castpd256_pd128(A);
154 }
155 
test_mm256_castps_pd(__m256 A)156 __m256d test_mm256_castps_pd(__m256 A) {
157   // CHECK-LABEL: test_mm256_castps_pd
158   // CHECK: bitcast <8 x float> %{{.*}} to <4 x double>
159   return _mm256_castps_pd(A);
160 }
161 
test_mm256_castps_si256(__m256 A)162 __m256i test_mm256_castps_si256(__m256 A) {
163   // CHECK-LABEL: test_mm256_castps_si256
164   // CHECK: bitcast <8 x float> %{{.*}} to <4 x i64>
165   return _mm256_castps_si256(A);
166 }
167 
test_mm256_castps128_ps256(__m128 A)168 __m256 test_mm256_castps128_ps256(__m128 A) {
169   // CHECK-LABEL: test_mm256_castps128_ps256
170   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
171   return _mm256_castps128_ps256(A);
172 }
173 
test_mm256_castps256_ps128(__m256 A)174 __m128 test_mm256_castps256_ps128(__m256 A) {
175   // CHECK-LABEL: test_mm256_castps256_ps128
176   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
177   return _mm256_castps256_ps128(A);
178 }
179 
test_mm256_castsi128_si256(__m128i A)180 __m256i test_mm256_castsi128_si256(__m128i A) {
181   // CHECK-LABEL: test_mm256_castsi128_si256
182   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
183   return _mm256_castsi128_si256(A);
184 }
185 
test_mm256_castsi256_pd(__m256i A)186 __m256d test_mm256_castsi256_pd(__m256i A) {
187   // CHECK-LABEL: test_mm256_castsi256_pd
188   // CHECK: bitcast <4 x i64> %{{.*}} to <4 x double>
189   return _mm256_castsi256_pd(A);
190 }
191 
test_mm256_castsi256_ps(__m256i A)192 __m256 test_mm256_castsi256_ps(__m256i A) {
193   // CHECK-LABEL: test_mm256_castsi256_ps
194   // CHECK: bitcast <4 x i64> %{{.*}} to <8 x float>
195   return _mm256_castsi256_ps(A);
196 }
197 
test_mm256_castsi256_si128(__m256i A)198 __m128i test_mm256_castsi256_si128(__m256i A) {
199   // CHECK-LABEL: test_mm256_castsi256_si128
200   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1>
201   return _mm256_castsi256_si128(A);
202 }
203 
test_mm256_ceil_pd(__m256d x)204 __m256d test_mm256_ceil_pd(__m256d x) {
205   // CHECK-LABEL: test_mm256_ceil_pd
206   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 2)
207   return _mm256_ceil_pd(x);
208 }
209 
test_mm_ceil_ps(__m256 x)210 __m256 test_mm_ceil_ps(__m256 x) {
211   // CHECK-LABEL: test_mm_ceil_ps
212   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 2)
213   return _mm256_ceil_ps(x);
214 }
215 
test_mm256_cmp_pd_eq_oq(__m256d a,__m256d b)216 __m256d test_mm256_cmp_pd_eq_oq(__m256d a, __m256d b) {
217   // CHECK-LABEL: test_mm256_cmp_pd_eq_oq
218   // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
219   return _mm256_cmp_pd(a, b, _CMP_EQ_OQ);
220 }
221 
test_mm256_cmp_pd_lt_os(__m256d a,__m256d b)222 __m256d test_mm256_cmp_pd_lt_os(__m256d a, __m256d b) {
223   // CHECK-LABEL: test_mm256_cmp_pd_lt_os
224   // CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}}
225   return _mm256_cmp_pd(a, b, _CMP_LT_OS);
226 }
227 
test_mm256_cmp_pd_le_os(__m256d a,__m256d b)228 __m256d test_mm256_cmp_pd_le_os(__m256d a, __m256d b) {
229   // CHECK-LABEL: test_mm256_cmp_pd_le_os
230   // CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}}
231   return _mm256_cmp_pd(a, b, _CMP_LE_OS);
232 }
233 
test_mm256_cmp_pd_unord_q(__m256d a,__m256d b)234 __m256d test_mm256_cmp_pd_unord_q(__m256d a, __m256d b) {
235   // CHECK-LABEL: test_mm256_cmp_pd_unord_q
236   // CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}}
237   return _mm256_cmp_pd(a, b, _CMP_UNORD_Q);
238 }
239 
test_mm256_cmp_pd_neq_uq(__m256d a,__m256d b)240 __m256d test_mm256_cmp_pd_neq_uq(__m256d a, __m256d b) {
241   // CHECK-LABEL: test_mm256_cmp_pd_neq_uq
242   // CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}}
243   return _mm256_cmp_pd(a, b, _CMP_NEQ_UQ);
244 }
245 
test_mm256_cmp_pd_nlt_us(__m256d a,__m256d b)246 __m256d test_mm256_cmp_pd_nlt_us(__m256d a, __m256d b) {
247   // CHECK-LABEL: test_mm256_cmp_pd_nlt_us
248   // CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}}
249   return _mm256_cmp_pd(a, b, _CMP_NLT_US);
250 }
251 
test_mm256_cmp_pd_nle_us(__m256d a,__m256d b)252 __m256d test_mm256_cmp_pd_nle_us(__m256d a, __m256d b) {
253   // CHECK-LABEL: test_mm256_cmp_pd_nle_us
254   // CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}}
255   return _mm256_cmp_pd(a, b, _CMP_NLE_US);
256 }
257 
test_mm256_cmp_pd_ord_q(__m256d a,__m256d b)258 __m256d test_mm256_cmp_pd_ord_q(__m256d a, __m256d b) {
259   // CHECK-LABEL: test_mm256_cmp_pd_ord_q
260   // CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}}
261   return _mm256_cmp_pd(a, b, _CMP_ORD_Q);
262 }
263 
test_mm256_cmp_pd_eq_uq(__m256d a,__m256d b)264 __m256d test_mm256_cmp_pd_eq_uq(__m256d a, __m256d b) {
265   // CHECK-LABEL: test_mm256_cmp_pd_eq_uq
266   // CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}}
267   return _mm256_cmp_pd(a, b, _CMP_EQ_UQ);
268 }
269 
test_mm256_cmp_pd_nge_us(__m256d a,__m256d b)270 __m256d test_mm256_cmp_pd_nge_us(__m256d a, __m256d b) {
271   // CHECK-LABEL: test_mm256_cmp_pd_nge_us
272   // CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}}
273   return _mm256_cmp_pd(a, b, _CMP_NGE_US);
274 }
275 
test_mm256_cmp_pd_ngt_us(__m256d a,__m256d b)276 __m256d test_mm256_cmp_pd_ngt_us(__m256d a, __m256d b) {
277   // CHECK-LABEL: test_mm256_cmp_pd_ngt_us
278   // CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}}
279   return _mm256_cmp_pd(a, b, _CMP_NGT_US);
280 }
281 
test_mm256_cmp_pd_false_oq(__m256d a,__m256d b)282 __m256d test_mm256_cmp_pd_false_oq(__m256d a, __m256d b) {
283   // CHECK-LABEL: test_mm256_cmp_pd_false_oq
284   // CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}}
285   return _mm256_cmp_pd(a, b, _CMP_FALSE_OQ);
286 }
287 
test_mm256_cmp_pd_neq_oq(__m256d a,__m256d b)288 __m256d test_mm256_cmp_pd_neq_oq(__m256d a, __m256d b) {
289   // CHECK-LABEL: test_mm256_cmp_pd_neq_oq
290   // CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}}
291   return _mm256_cmp_pd(a, b, _CMP_NEQ_OQ);
292 }
293 
test_mm256_cmp_pd_ge_os(__m256d a,__m256d b)294 __m256d test_mm256_cmp_pd_ge_os(__m256d a, __m256d b) {
295   // CHECK-LABEL: test_mm256_cmp_pd_ge_os
296   // CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}}
297   return _mm256_cmp_pd(a, b, _CMP_GE_OS);
298 }
299 
test_mm256_cmp_pd_gt_os(__m256d a,__m256d b)300 __m256d test_mm256_cmp_pd_gt_os(__m256d a, __m256d b) {
301   // CHECK-LABEL: test_mm256_cmp_pd_gt_os
302   // CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}}
303   return _mm256_cmp_pd(a, b, _CMP_GT_OS);
304 }
305 
test_mm256_cmp_pd_true_uq(__m256d a,__m256d b)306 __m256d test_mm256_cmp_pd_true_uq(__m256d a, __m256d b) {
307   // CHECK-LABEL: test_mm256_cmp_pd_true_uq
308   // CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}}
309   return _mm256_cmp_pd(a, b, _CMP_TRUE_UQ);
310 }
311 
test_mm256_cmp_pd_eq_os(__m256d a,__m256d b)312 __m256d test_mm256_cmp_pd_eq_os(__m256d a, __m256d b) {
313   // CHECK-LABEL: test_mm256_cmp_pd_eq_os
314   // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
315   return _mm256_cmp_pd(a, b, _CMP_EQ_OS);
316 }
317 
test_mm256_cmp_pd_lt_oq(__m256d a,__m256d b)318 __m256d test_mm256_cmp_pd_lt_oq(__m256d a, __m256d b) {
319   // CHECK-LABEL: test_mm256_cmp_pd_lt_oq
320   // CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}}
321   return _mm256_cmp_pd(a, b, _CMP_LT_OQ);
322 }
323 
test_mm256_cmp_pd_le_oq(__m256d a,__m256d b)324 __m256d test_mm256_cmp_pd_le_oq(__m256d a, __m256d b) {
325   // CHECK-LABEL: test_mm256_cmp_pd_le_oq
326   // CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}}
327   return _mm256_cmp_pd(a, b, _CMP_LE_OQ);
328 }
329 
test_mm256_cmp_pd_unord_s(__m256d a,__m256d b)330 __m256d test_mm256_cmp_pd_unord_s(__m256d a, __m256d b) {
331   // CHECK-LABEL: test_mm256_cmp_pd_unord_s
332   // CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}}
333   return _mm256_cmp_pd(a, b, _CMP_UNORD_S);
334 }
335 
test_mm256_cmp_pd_neq_us(__m256d a,__m256d b)336 __m256d test_mm256_cmp_pd_neq_us(__m256d a, __m256d b) {
337   // CHECK-LABEL: test_mm256_cmp_pd_neq_us
338   // CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}}
339   return _mm256_cmp_pd(a, b, _CMP_NEQ_US);
340 }
341 
test_mm256_cmp_pd_nlt_uq(__m256d a,__m256d b)342 __m256d test_mm256_cmp_pd_nlt_uq(__m256d a, __m256d b) {
343   // CHECK-LABEL: test_mm256_cmp_pd_nlt_uq
344   // CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}}
345   return _mm256_cmp_pd(a, b, _CMP_NLT_UQ);
346 }
347 
test_mm256_cmp_pd_nle_uq(__m256d a,__m256d b)348 __m256d test_mm256_cmp_pd_nle_uq(__m256d a, __m256d b) {
349   // CHECK-LABEL: test_mm256_cmp_pd_nle_uq
350   // CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}}
351   return _mm256_cmp_pd(a, b, _CMP_NLE_UQ);
352 }
353 
test_mm256_cmp_pd_ord_s(__m256d a,__m256d b)354 __m256d test_mm256_cmp_pd_ord_s(__m256d a, __m256d b) {
355   // CHECK-LABEL: test_mm256_cmp_pd_ord_s
356   // CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}}
357   return _mm256_cmp_pd(a, b, _CMP_ORD_S);
358 }
359 
test_mm256_cmp_pd_eq_us(__m256d a,__m256d b)360 __m256d test_mm256_cmp_pd_eq_us(__m256d a, __m256d b) {
361   // CHECK-LABEL: test_mm256_cmp_pd_eq_us
362   // CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}}
363   return _mm256_cmp_pd(a, b, _CMP_EQ_US);
364 }
365 
test_mm256_cmp_pd_nge_uq(__m256d a,__m256d b)366 __m256d test_mm256_cmp_pd_nge_uq(__m256d a, __m256d b) {
367   // CHECK-LABEL: test_mm256_cmp_pd_nge_uq
368   // CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}}
369   return _mm256_cmp_pd(a, b, _CMP_NGE_UQ);
370 }
371 
test_mm256_cmp_pd_ngt_uq(__m256d a,__m256d b)372 __m256d test_mm256_cmp_pd_ngt_uq(__m256d a, __m256d b) {
373   // CHECK-LABEL: test_mm256_cmp_pd_ngt_uq
374   // CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}}
375   return _mm256_cmp_pd(a, b, _CMP_NGT_UQ);
376 }
377 
test_mm256_cmp_pd_false_os(__m256d a,__m256d b)378 __m256d test_mm256_cmp_pd_false_os(__m256d a, __m256d b) {
379   // CHECK-LABEL: test_mm256_cmp_pd_false_os
380   // CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}}
381   return _mm256_cmp_pd(a, b, _CMP_FALSE_OS);
382 }
383 
test_mm256_cmp_pd_neq_os(__m256d a,__m256d b)384 __m256d test_mm256_cmp_pd_neq_os(__m256d a, __m256d b) {
385   // CHECK-LABEL: test_mm256_cmp_pd_neq_os
386   // CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}}
387   return _mm256_cmp_pd(a, b, _CMP_NEQ_OS);
388 }
389 
test_mm256_cmp_pd_ge_oq(__m256d a,__m256d b)390 __m256d test_mm256_cmp_pd_ge_oq(__m256d a, __m256d b) {
391   // CHECK-LABEL: test_mm256_cmp_pd_ge_oq
392   // CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}}
393   return _mm256_cmp_pd(a, b, _CMP_GE_OQ);
394 }
395 
test_mm256_cmp_pd_gt_oq(__m256d a,__m256d b)396 __m256d test_mm256_cmp_pd_gt_oq(__m256d a, __m256d b) {
397   // CHECK-LABEL: test_mm256_cmp_pd_gt_oq
398   // CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}}
399   return _mm256_cmp_pd(a, b, _CMP_GT_OQ);
400 }
401 
test_mm256_cmp_pd_true_us(__m256d a,__m256d b)402 __m256d test_mm256_cmp_pd_true_us(__m256d a, __m256d b) {
403   // CHECK-LABEL: test_mm256_cmp_pd_true_us
404   // CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}}
405   return _mm256_cmp_pd(a, b, _CMP_TRUE_US);
406 }
407 
test_mm256_cmp_ps_eq_oq(__m256 a,__m256 b)408 __m256 test_mm256_cmp_ps_eq_oq(__m256 a, __m256 b) {
409   // CHECK-LABEL: test_mm256_cmp_ps_eq_oq
410   // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
411   return _mm256_cmp_ps(a, b, _CMP_EQ_OQ);
412 }
413 
test_mm256_cmp_ps_lt_os(__m256 a,__m256 b)414 __m256 test_mm256_cmp_ps_lt_os(__m256 a, __m256 b) {
415   // CHECK-LABEL: test_mm256_cmp_ps_lt_os
416   // CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}}
417   return _mm256_cmp_ps(a, b, _CMP_LT_OS);
418 }
419 
test_mm256_cmp_ps_le_os(__m256 a,__m256 b)420 __m256 test_mm256_cmp_ps_le_os(__m256 a, __m256 b) {
421   // CHECK-LABEL: test_mm256_cmp_ps_le_os
422   // CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}}
423   return _mm256_cmp_ps(a, b, _CMP_LE_OS);
424 }
425 
test_mm256_cmp_ps_unord_q(__m256 a,__m256 b)426 __m256 test_mm256_cmp_ps_unord_q(__m256 a, __m256 b) {
427   // CHECK-LABEL: test_mm256_cmp_ps_unord_q
428   // CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}}
429   return _mm256_cmp_ps(a, b, _CMP_UNORD_Q);
430 }
431 
test_mm256_cmp_ps_neq_uq(__m256 a,__m256 b)432 __m256 test_mm256_cmp_ps_neq_uq(__m256 a, __m256 b) {
433   // CHECK-LABEL: test_mm256_cmp_ps_neq_uq
434   // CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}}
435   return _mm256_cmp_ps(a, b, _CMP_NEQ_UQ);
436 }
437 
test_mm256_cmp_ps_nlt_us(__m256 a,__m256 b)438 __m256 test_mm256_cmp_ps_nlt_us(__m256 a, __m256 b) {
439   // CHECK-LABEL: test_mm256_cmp_ps_nlt_us
440   // CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}}
441   return _mm256_cmp_ps(a, b, _CMP_NLT_US);
442 }
443 
test_mm256_cmp_ps_nle_us(__m256 a,__m256 b)444 __m256 test_mm256_cmp_ps_nle_us(__m256 a, __m256 b) {
445   // CHECK-LABEL: test_mm256_cmp_ps_nle_us
446   // CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}}
447   return _mm256_cmp_ps(a, b, _CMP_NLE_US);
448 }
449 
test_mm256_cmp_ps_ord_q(__m256 a,__m256 b)450 __m256 test_mm256_cmp_ps_ord_q(__m256 a, __m256 b) {
451   // CHECK-LABEL: test_mm256_cmp_ps_ord_q
452   // CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}}
453   return _mm256_cmp_ps(a, b, _CMP_ORD_Q);
454 }
455 
test_mm256_cmp_ps_eq_uq(__m256 a,__m256 b)456 __m256 test_mm256_cmp_ps_eq_uq(__m256 a, __m256 b) {
457   // CHECK-LABEL: test_mm256_cmp_ps_eq_uq
458   // CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}}
459   return _mm256_cmp_ps(a, b, _CMP_EQ_UQ);
460 }
461 
test_mm256_cmp_ps_nge_us(__m256 a,__m256 b)462 __m256 test_mm256_cmp_ps_nge_us(__m256 a, __m256 b) {
463   // CHECK-LABEL: test_mm256_cmp_ps_nge_us
464   // CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}}
465   return _mm256_cmp_ps(a, b, _CMP_NGE_US);
466 }
467 
test_mm256_cmp_ps_ngt_us(__m256 a,__m256 b)468 __m256 test_mm256_cmp_ps_ngt_us(__m256 a, __m256 b) {
469   // CHECK-LABEL: test_mm256_cmp_ps_ngt_us
470   // CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}}
471   return _mm256_cmp_ps(a, b, _CMP_NGT_US);
472 }
473 
test_mm256_cmp_ps_false_oq(__m256 a,__m256 b)474 __m256 test_mm256_cmp_ps_false_oq(__m256 a, __m256 b) {
475   // CHECK-LABEL: test_mm256_cmp_ps_false_oq
476   // CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}}
477   return _mm256_cmp_ps(a, b, _CMP_FALSE_OQ);
478 }
479 
test_mm256_cmp_ps_neq_oq(__m256 a,__m256 b)480 __m256 test_mm256_cmp_ps_neq_oq(__m256 a, __m256 b) {
481   // CHECK-LABEL: test_mm256_cmp_ps_neq_oq
482   // CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}}
483   return _mm256_cmp_ps(a, b, _CMP_NEQ_OQ);
484 }
485 
test_mm256_cmp_ps_ge_os(__m256 a,__m256 b)486 __m256 test_mm256_cmp_ps_ge_os(__m256 a, __m256 b) {
487   // CHECK-LABEL: test_mm256_cmp_ps_ge_os
488   // CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}}
489   return _mm256_cmp_ps(a, b, _CMP_GE_OS);
490 }
491 
test_mm256_cmp_ps_gt_os(__m256 a,__m256 b)492 __m256 test_mm256_cmp_ps_gt_os(__m256 a, __m256 b) {
493   // CHECK-LABEL: test_mm256_cmp_ps_gt_os
494   // CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}}
495   return _mm256_cmp_ps(a, b, _CMP_GT_OS);
496 }
497 
test_mm256_cmp_ps_true_uq(__m256 a,__m256 b)498 __m256 test_mm256_cmp_ps_true_uq(__m256 a, __m256 b) {
499   // CHECK-LABEL: test_mm256_cmp_ps_true_uq
500   // CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}}
501   return _mm256_cmp_ps(a, b, _CMP_TRUE_UQ);
502 }
503 
test_mm256_cmp_ps_eq_os(__m256 a,__m256 b)504 __m256 test_mm256_cmp_ps_eq_os(__m256 a, __m256 b) {
505   // CHECK-LABEL: test_mm256_cmp_ps_eq_os
506   // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
507   return _mm256_cmp_ps(a, b, _CMP_EQ_OS);
508 }
509 
test_mm256_cmp_ps_lt_oq(__m256 a,__m256 b)510 __m256 test_mm256_cmp_ps_lt_oq(__m256 a, __m256 b) {
511   // CHECK-LABEL: test_mm256_cmp_ps_lt_oq
512   // CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}}
513   return _mm256_cmp_ps(a, b, _CMP_LT_OQ);
514 }
515 
test_mm256_cmp_ps_le_oq(__m256 a,__m256 b)516 __m256 test_mm256_cmp_ps_le_oq(__m256 a, __m256 b) {
517   // CHECK-LABEL: test_mm256_cmp_ps_le_oq
518   // CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}}
519   return _mm256_cmp_ps(a, b, _CMP_LE_OQ);
520 }
521 
test_mm256_cmp_ps_unord_s(__m256 a,__m256 b)522 __m256 test_mm256_cmp_ps_unord_s(__m256 a, __m256 b) {
523   // CHECK-LABEL: test_mm256_cmp_ps_unord_s
524   // CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}}
525   return _mm256_cmp_ps(a, b, _CMP_UNORD_S);
526 }
527 
test_mm256_cmp_ps_neq_us(__m256 a,__m256 b)528 __m256 test_mm256_cmp_ps_neq_us(__m256 a, __m256 b) {
529   // CHECK-LABEL: test_mm256_cmp_ps_neq_us
530   // CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}}
531   return _mm256_cmp_ps(a, b, _CMP_NEQ_US);
532 }
533 
test_mm256_cmp_ps_nlt_uq(__m256 a,__m256 b)534 __m256 test_mm256_cmp_ps_nlt_uq(__m256 a, __m256 b) {
535   // CHECK-LABEL: test_mm256_cmp_ps_nlt_uq
536   // CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}}
537   return _mm256_cmp_ps(a, b, _CMP_NLT_UQ);
538 }
539 
test_mm256_cmp_ps_nle_uq(__m256 a,__m256 b)540 __m256 test_mm256_cmp_ps_nle_uq(__m256 a, __m256 b) {
541   // CHECK-LABEL: test_mm256_cmp_ps_nle_uq
542   // CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}}
543   return _mm256_cmp_ps(a, b, _CMP_NLE_UQ);
544 }
545 
test_mm256_cmp_ps_ord_s(__m256 a,__m256 b)546 __m256 test_mm256_cmp_ps_ord_s(__m256 a, __m256 b) {
547   // CHECK-LABEL: test_mm256_cmp_ps_ord_s
548   // CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}}
549   return _mm256_cmp_ps(a, b, _CMP_ORD_S);
550 }
551 
test_mm256_cmp_ps_eq_us(__m256 a,__m256 b)552 __m256 test_mm256_cmp_ps_eq_us(__m256 a, __m256 b) {
553   // CHECK-LABEL: test_mm256_cmp_ps_eq_us
554   // CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}}
555   return _mm256_cmp_ps(a, b, _CMP_EQ_US);
556 }
557 
test_mm256_cmp_ps_nge_uq(__m256 a,__m256 b)558 __m256 test_mm256_cmp_ps_nge_uq(__m256 a, __m256 b) {
559   // CHECK-LABEL: test_mm256_cmp_ps_nge_uq
560   // CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}}
561   return _mm256_cmp_ps(a, b, _CMP_NGE_UQ);
562 }
563 
test_mm256_cmp_ps_ngt_uq(__m256 a,__m256 b)564 __m256 test_mm256_cmp_ps_ngt_uq(__m256 a, __m256 b) {
565   // CHECK-LABEL: test_mm256_cmp_ps_ngt_uq
566   // CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}}
567   return _mm256_cmp_ps(a, b, _CMP_NGT_UQ);
568 }
569 
test_mm256_cmp_ps_false_os(__m256 a,__m256 b)570 __m256 test_mm256_cmp_ps_false_os(__m256 a, __m256 b) {
571   // CHECK-LABEL: test_mm256_cmp_ps_false_os
572   // CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}}
573   return _mm256_cmp_ps(a, b, _CMP_FALSE_OS);
574 }
575 
test_mm256_cmp_ps_neq_os(__m256 a,__m256 b)576 __m256 test_mm256_cmp_ps_neq_os(__m256 a, __m256 b) {
577   // CHECK-LABEL: test_mm256_cmp_ps_neq_os
578   // CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}}
579   return _mm256_cmp_ps(a, b, _CMP_NEQ_OS);
580 }
581 
test_mm256_cmp_ps_ge_oq(__m256 a,__m256 b)582 __m256 test_mm256_cmp_ps_ge_oq(__m256 a, __m256 b) {
583   // CHECK-LABEL: test_mm256_cmp_ps_ge_oq
584   // CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}}
585   return _mm256_cmp_ps(a, b, _CMP_GE_OQ);
586 }
587 
test_mm256_cmp_ps_gt_oq(__m256 a,__m256 b)588 __m256 test_mm256_cmp_ps_gt_oq(__m256 a, __m256 b) {
589   // CHECK-LABEL: test_mm256_cmp_ps_gt_oq
590   // CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}}
591   return _mm256_cmp_ps(a, b, _CMP_GT_OQ);
592 }
593 
test_mm256_cmp_ps_true_us(__m256 a,__m256 b)594 __m256 test_mm256_cmp_ps_true_us(__m256 a, __m256 b) {
595   // CHECK-LABEL: test_mm256_cmp_ps_true_us
596   // CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}}
597   return _mm256_cmp_ps(a, b, _CMP_TRUE_US);
598 }
599 
test_mm_cmp_pd_eq_oq(__m128d a,__m128d b)600 __m128d test_mm_cmp_pd_eq_oq(__m128d a, __m128d b) {
601   // CHECK-LABEL: test_mm_cmp_pd_eq_oq
602   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
603   return _mm_cmp_pd(a, b, _CMP_EQ_OQ);
604 }
605 
test_mm_cmp_pd_lt_os(__m128d a,__m128d b)606 __m128d test_mm_cmp_pd_lt_os(__m128d a, __m128d b) {
607   // CHECK-LABEL: test_mm_cmp_pd_lt_os
608   // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
609   return _mm_cmp_pd(a, b, _CMP_LT_OS);
610 }
611 
test_mm_cmp_pd_le_os(__m128d a,__m128d b)612 __m128d test_mm_cmp_pd_le_os(__m128d a, __m128d b) {
613   // CHECK-LABEL: test_mm_cmp_pd_le_os
614   // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
615   return _mm_cmp_pd(a, b, _CMP_LE_OS);
616 }
617 
test_mm_cmp_pd_unord_q(__m128d a,__m128d b)618 __m128d test_mm_cmp_pd_unord_q(__m128d a, __m128d b) {
619   // CHECK-LABEL: test_mm_cmp_pd_unord_q
620   // CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}}
621   return _mm_cmp_pd(a, b, _CMP_UNORD_Q);
622 }
623 
test_mm_cmp_pd_neq_uq(__m128d a,__m128d b)624 __m128d test_mm_cmp_pd_neq_uq(__m128d a, __m128d b) {
625   // CHECK-LABEL: test_mm_cmp_pd_neq_uq
626   // CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}}
627   return _mm_cmp_pd(a, b, _CMP_NEQ_UQ);
628 }
629 
test_mm_cmp_pd_nlt_us(__m128d a,__m128d b)630 __m128d test_mm_cmp_pd_nlt_us(__m128d a, __m128d b) {
631   // CHECK-LABEL: test_mm_cmp_pd_nlt_us
632   // CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}}
633   return _mm_cmp_pd(a, b, _CMP_NLT_US);
634 }
635 
test_mm_cmp_pd_nle_us(__m128d a,__m128d b)636 __m128d test_mm_cmp_pd_nle_us(__m128d a, __m128d b) {
637   // CHECK-LABEL: test_mm_cmp_pd_nle_us
638   // CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}}
639   return _mm_cmp_pd(a, b, _CMP_NLE_US);
640 }
641 
test_mm_cmp_pd_ord_q(__m128d a,__m128d b)642 __m128d test_mm_cmp_pd_ord_q(__m128d a, __m128d b) {
643   // CHECK-LABEL: test_mm_cmp_pd_ord_q
644   // CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}}
645   return _mm_cmp_pd(a, b, _CMP_ORD_Q);
646 }
647 
test_mm_cmp_pd_eq_uq(__m128d a,__m128d b)648 __m128d test_mm_cmp_pd_eq_uq(__m128d a, __m128d b) {
649   // CHECK-LABEL: test_mm_cmp_pd_eq_uq
650   // CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}}
651   return _mm_cmp_pd(a, b, _CMP_EQ_UQ);
652 }
653 
test_mm_cmp_pd_nge_us(__m128d a,__m128d b)654 __m128d test_mm_cmp_pd_nge_us(__m128d a, __m128d b) {
655   // CHECK-LABEL: test_mm_cmp_pd_nge_us
656   // CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}}
657   return _mm_cmp_pd(a, b, _CMP_NGE_US);
658 }
659 
test_mm_cmp_pd_ngt_us(__m128d a,__m128d b)660 __m128d test_mm_cmp_pd_ngt_us(__m128d a, __m128d b) {
661   // CHECK-LABEL: test_mm_cmp_pd_ngt_us
662   // CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}}
663   return _mm_cmp_pd(a, b, _CMP_NGT_US);
664 }
665 
test_mm_cmp_pd_false_oq(__m128d a,__m128d b)666 __m128d test_mm_cmp_pd_false_oq(__m128d a, __m128d b) {
667   // CHECK-LABEL: test_mm_cmp_pd_false_oq
668   // CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}}
669   return _mm_cmp_pd(a, b, _CMP_FALSE_OQ);
670 }
671 
test_mm_cmp_pd_neq_oq(__m128d a,__m128d b)672 __m128d test_mm_cmp_pd_neq_oq(__m128d a, __m128d b) {
673   // CHECK-LABEL: test_mm_cmp_pd_neq_oq
674   // CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}}
675   return _mm_cmp_pd(a, b, _CMP_NEQ_OQ);
676 }
677 
test_mm_cmp_pd_ge_os(__m128d a,__m128d b)678 __m128d test_mm_cmp_pd_ge_os(__m128d a, __m128d b) {
679   // CHECK-LABEL: test_mm_cmp_pd_ge_os
680   // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
681   return _mm_cmp_pd(a, b, _CMP_GE_OS);
682 }
683 
test_mm_cmp_pd_gt_os(__m128d a,__m128d b)684 __m128d test_mm_cmp_pd_gt_os(__m128d a, __m128d b) {
685   // CHECK-LABEL: test_mm_cmp_pd_gt_os
686   // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
687   return _mm_cmp_pd(a, b, _CMP_GT_OS);
688 }
689 
test_mm_cmp_pd_true_uq(__m128d a,__m128d b)690 __m128d test_mm_cmp_pd_true_uq(__m128d a, __m128d b) {
691   // CHECK-LABEL: test_mm_cmp_pd_true_uq
692   // CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}}
693   return _mm_cmp_pd(a, b, _CMP_TRUE_UQ);
694 }
695 
test_mm_cmp_pd_eq_os(__m128d a,__m128d b)696 __m128d test_mm_cmp_pd_eq_os(__m128d a, __m128d b) {
697   // CHECK-LABEL: test_mm_cmp_pd_eq_os
698   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
699   return _mm_cmp_pd(a, b, _CMP_EQ_OS);
700 }
701 
test_mm_cmp_pd_lt_oq(__m128d a,__m128d b)702 __m128d test_mm_cmp_pd_lt_oq(__m128d a, __m128d b) {
703   // CHECK-LABEL: test_mm_cmp_pd_lt_oq
704   // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
705   return _mm_cmp_pd(a, b, _CMP_LT_OQ);
706 }
707 
test_mm_cmp_pd_le_oq(__m128d a,__m128d b)708 __m128d test_mm_cmp_pd_le_oq(__m128d a, __m128d b) {
709   // CHECK-LABEL: test_mm_cmp_pd_le_oq
710   // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
711   return _mm_cmp_pd(a, b, _CMP_LE_OQ);
712 }
713 
test_mm_cmp_pd_unord_s(__m128d a,__m128d b)714 __m128d test_mm_cmp_pd_unord_s(__m128d a, __m128d b) {
715   // CHECK-LABEL: test_mm_cmp_pd_unord_s
716   // CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}}
717   return _mm_cmp_pd(a, b, _CMP_UNORD_S);
718 }
719 
test_mm_cmp_pd_neq_us(__m128d a,__m128d b)720 __m128d test_mm_cmp_pd_neq_us(__m128d a, __m128d b) {
721   // CHECK-LABEL: test_mm_cmp_pd_neq_us
722   // CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}}
723   return _mm_cmp_pd(a, b, _CMP_NEQ_US);
724 }
725 
test_mm_cmp_pd_nlt_uq(__m128d a,__m128d b)726 __m128d test_mm_cmp_pd_nlt_uq(__m128d a, __m128d b) {
727   // CHECK-LABEL: test_mm_cmp_pd_nlt_uq
728   // CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}}
729   return _mm_cmp_pd(a, b, _CMP_NLT_UQ);
730 }
731 
test_mm_cmp_pd_nle_uq(__m128d a,__m128d b)732 __m128d test_mm_cmp_pd_nle_uq(__m128d a, __m128d b) {
733   // CHECK-LABEL: test_mm_cmp_pd_nle_uq
734   // CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}}
735   return _mm_cmp_pd(a, b, _CMP_NLE_UQ);
736 }
737 
test_mm_cmp_pd_ord_s(__m128d a,__m128d b)738 __m128d test_mm_cmp_pd_ord_s(__m128d a, __m128d b) {
739   // CHECK-LABEL: test_mm_cmp_pd_ord_s
740   // CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}}
741   return _mm_cmp_pd(a, b, _CMP_ORD_S);
742 }
743 
test_mm_cmp_pd_eq_us(__m128d a,__m128d b)744 __m128d test_mm_cmp_pd_eq_us(__m128d a, __m128d b) {
745   // CHECK-LABEL: test_mm_cmp_pd_eq_us
746   // CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}}
747   return _mm_cmp_pd(a, b, _CMP_EQ_US);
748 }
749 
test_mm_cmp_pd_nge_uq(__m128d a,__m128d b)750 __m128d test_mm_cmp_pd_nge_uq(__m128d a, __m128d b) {
751   // CHECK-LABEL: test_mm_cmp_pd_nge_uq
752   // CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}}
753   return _mm_cmp_pd(a, b, _CMP_NGE_UQ);
754 }
755 
test_mm_cmp_pd_ngt_uq(__m128d a,__m128d b)756 __m128d test_mm_cmp_pd_ngt_uq(__m128d a, __m128d b) {
757   // CHECK-LABEL: test_mm_cmp_pd_ngt_uq
758   // CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}}
759   return _mm_cmp_pd(a, b, _CMP_NGT_UQ);
760 }
761 
test_mm_cmp_pd_false_os(__m128d a,__m128d b)762 __m128d test_mm_cmp_pd_false_os(__m128d a, __m128d b) {
763   // CHECK-LABEL: test_mm_cmp_pd_false_os
764   // CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}}
765   return _mm_cmp_pd(a, b, _CMP_FALSE_OS);
766 }
767 
test_mm_cmp_pd_neq_os(__m128d a,__m128d b)768 __m128d test_mm_cmp_pd_neq_os(__m128d a, __m128d b) {
769   // CHECK-LABEL: test_mm_cmp_pd_neq_os
770   // CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}}
771   return _mm_cmp_pd(a, b, _CMP_NEQ_OS);
772 }
773 
test_mm_cmp_pd_ge_oq(__m128d a,__m128d b)774 __m128d test_mm_cmp_pd_ge_oq(__m128d a, __m128d b) {
775   // CHECK-LABEL: test_mm_cmp_pd_ge_oq
776   // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
777   return _mm_cmp_pd(a, b, _CMP_GE_OQ);
778 }
779 
test_mm_cmp_pd_gt_oq(__m128d a,__m128d b)780 __m128d test_mm_cmp_pd_gt_oq(__m128d a, __m128d b) {
781   // CHECK-LABEL: test_mm_cmp_pd_gt_oq
782   // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
783   return _mm_cmp_pd(a, b, _CMP_GT_OQ);
784 }
785 
test_mm_cmp_pd_true_us(__m128d a,__m128d b)786 __m128d test_mm_cmp_pd_true_us(__m128d a, __m128d b) {
787   // CHECK-LABEL: test_mm_cmp_pd_true_us
788   // CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}}
789   return _mm_cmp_pd(a, b, _CMP_TRUE_US);
790 }
791 
test_mm_cmp_ps_eq_oq(__m128 a,__m128 b)792 __m128 test_mm_cmp_ps_eq_oq(__m128 a, __m128 b) {
793   // CHECK-LABEL: test_mm_cmp_ps_eq_oq
794   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
795   return _mm_cmp_ps(a, b, _CMP_EQ_OQ);
796 }
797 
test_mm_cmp_ps_lt_os(__m128 a,__m128 b)798 __m128 test_mm_cmp_ps_lt_os(__m128 a, __m128 b) {
799   // CHECK-LABEL: test_mm_cmp_ps_lt_os
800   // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
801   return _mm_cmp_ps(a, b, _CMP_LT_OS);
802 }
803 
test_mm_cmp_ps_le_os(__m128 a,__m128 b)804 __m128 test_mm_cmp_ps_le_os(__m128 a, __m128 b) {
805   // CHECK-LABEL: test_mm_cmp_ps_le_os
806   // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
807   return _mm_cmp_ps(a, b, _CMP_LE_OS);
808 }
809 
test_mm_cmp_ps_unord_q(__m128 a,__m128 b)810 __m128 test_mm_cmp_ps_unord_q(__m128 a, __m128 b) {
811   // CHECK-LABEL: test_mm_cmp_ps_unord_q
812   // CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}}
813   return _mm_cmp_ps(a, b, _CMP_UNORD_Q);
814 }
815 
test_mm_cmp_ps_neq_uq(__m128 a,__m128 b)816 __m128 test_mm_cmp_ps_neq_uq(__m128 a, __m128 b) {
817   // CHECK-LABEL: test_mm_cmp_ps_neq_uq
818   // CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}}
819   return _mm_cmp_ps(a, b, _CMP_NEQ_UQ);
820 }
821 
test_mm_cmp_ps_nlt_us(__m128 a,__m128 b)822 __m128 test_mm_cmp_ps_nlt_us(__m128 a, __m128 b) {
823   // CHECK-LABEL: test_mm_cmp_ps_nlt_us
824   // CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}}
825   return _mm_cmp_ps(a, b, _CMP_NLT_US);
826 }
827 
test_mm_cmp_ps_nle_us(__m128 a,__m128 b)828 __m128 test_mm_cmp_ps_nle_us(__m128 a, __m128 b) {
829   // CHECK-LABEL: test_mm_cmp_ps_nle_us
830   // CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}}
831   return _mm_cmp_ps(a, b, _CMP_NLE_US);
832 }
833 
test_mm_cmp_ps_ord_q(__m128 a,__m128 b)834 __m128 test_mm_cmp_ps_ord_q(__m128 a, __m128 b) {
835   // CHECK-LABEL: test_mm_cmp_ps_ord_q
836   // CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}}
837   return _mm_cmp_ps(a, b, _CMP_ORD_Q);
838 }
839 
test_mm_cmp_ps_eq_uq(__m128 a,__m128 b)840 __m128 test_mm_cmp_ps_eq_uq(__m128 a, __m128 b) {
841   // CHECK-LABEL: test_mm_cmp_ps_eq_uq
842   // CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}}
843   return _mm_cmp_ps(a, b, _CMP_EQ_UQ);
844 }
845 
test_mm_cmp_ps_nge_us(__m128 a,__m128 b)846 __m128 test_mm_cmp_ps_nge_us(__m128 a, __m128 b) {
847   // CHECK-LABEL: test_mm_cmp_ps_nge_us
848   // CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}}
849   return _mm_cmp_ps(a, b, _CMP_NGE_US);
850 }
851 
test_mm_cmp_ps_ngt_us(__m128 a,__m128 b)852 __m128 test_mm_cmp_ps_ngt_us(__m128 a, __m128 b) {
853   // CHECK-LABEL: test_mm_cmp_ps_ngt_us
854   // CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}}
855   return _mm_cmp_ps(a, b, _CMP_NGT_US);
856 }
857 
test_mm_cmp_ps_false_oq(__m128 a,__m128 b)858 __m128 test_mm_cmp_ps_false_oq(__m128 a, __m128 b) {
859   // CHECK-LABEL: test_mm_cmp_ps_false_oq
860   // CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}}
861   return _mm_cmp_ps(a, b, _CMP_FALSE_OQ);
862 }
863 
test_mm_cmp_ps_neq_oq(__m128 a,__m128 b)864 __m128 test_mm_cmp_ps_neq_oq(__m128 a, __m128 b) {
865   // CHECK-LABEL: test_mm_cmp_ps_neq_oq
866   // CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}}
867   return _mm_cmp_ps(a, b, _CMP_NEQ_OQ);
868 }
869 
test_mm_cmp_ps_ge_os(__m128 a,__m128 b)870 __m128 test_mm_cmp_ps_ge_os(__m128 a, __m128 b) {
871   // CHECK-LABEL: test_mm_cmp_ps_ge_os
872   // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
873   return _mm_cmp_ps(a, b, _CMP_GE_OS);
874 }
875 
test_mm_cmp_ps_gt_os(__m128 a,__m128 b)876 __m128 test_mm_cmp_ps_gt_os(__m128 a, __m128 b) {
877   // CHECK-LABEL: test_mm_cmp_ps_gt_os
878   // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
879   return _mm_cmp_ps(a, b, _CMP_GT_OS);
880 }
881 
test_mm_cmp_ps_true_uq(__m128 a,__m128 b)882 __m128 test_mm_cmp_ps_true_uq(__m128 a, __m128 b) {
883   // CHECK-LABEL: test_mm_cmp_ps_true_uq
884   // CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}}
885   return _mm_cmp_ps(a, b, _CMP_TRUE_UQ);
886 }
887 
test_mm_cmp_ps_eq_os(__m128 a,__m128 b)888 __m128 test_mm_cmp_ps_eq_os(__m128 a, __m128 b) {
889   // CHECK-LABEL: test_mm_cmp_ps_eq_os
890   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
891   return _mm_cmp_ps(a, b, _CMP_EQ_OS);
892 }
893 
test_mm_cmp_ps_lt_oq(__m128 a,__m128 b)894 __m128 test_mm_cmp_ps_lt_oq(__m128 a, __m128 b) {
895   // CHECK-LABEL: test_mm_cmp_ps_lt_oq
896   // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
897   return _mm_cmp_ps(a, b, _CMP_LT_OQ);
898 }
899 
test_mm_cmp_ps_le_oq(__m128 a,__m128 b)900 __m128 test_mm_cmp_ps_le_oq(__m128 a, __m128 b) {
901   // CHECK-LABEL: test_mm_cmp_ps_le_oq
902   // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
903   return _mm_cmp_ps(a, b, _CMP_LE_OQ);
904 }
905 
test_mm_cmp_ps_unord_s(__m128 a,__m128 b)906 __m128 test_mm_cmp_ps_unord_s(__m128 a, __m128 b) {
907   // CHECK-LABEL: test_mm_cmp_ps_unord_s
908   // CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}}
909   return _mm_cmp_ps(a, b, _CMP_UNORD_S);
910 }
911 
test_mm_cmp_ps_neq_us(__m128 a,__m128 b)912 __m128 test_mm_cmp_ps_neq_us(__m128 a, __m128 b) {
913   // CHECK-LABEL: test_mm_cmp_ps_neq_us
914   // CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}}
915   return _mm_cmp_ps(a, b, _CMP_NEQ_US);
916 }
917 
test_mm_cmp_ps_nlt_uq(__m128 a,__m128 b)918 __m128 test_mm_cmp_ps_nlt_uq(__m128 a, __m128 b) {
919   // CHECK-LABEL: test_mm_cmp_ps_nlt_uq
920   // CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}}
921   return _mm_cmp_ps(a, b, _CMP_NLT_UQ);
922 }
923 
test_mm_cmp_ps_nle_uq(__m128 a,__m128 b)924 __m128 test_mm_cmp_ps_nle_uq(__m128 a, __m128 b) {
925   // CHECK-LABEL: test_mm_cmp_ps_nle_uq
926   // CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}}
927   return _mm_cmp_ps(a, b, _CMP_NLE_UQ);
928 }
929 
test_mm_cmp_ps_ord_s(__m128 a,__m128 b)930 __m128 test_mm_cmp_ps_ord_s(__m128 a, __m128 b) {
931   // CHECK-LABEL: test_mm_cmp_ps_ord_s
932   // CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}}
933   return _mm_cmp_ps(a, b, _CMP_ORD_S);
934 }
935 
test_mm_cmp_ps_eq_us(__m128 a,__m128 b)936 __m128 test_mm_cmp_ps_eq_us(__m128 a, __m128 b) {
937   // CHECK-LABEL: test_mm_cmp_ps_eq_us
938   // CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}}
939   return _mm_cmp_ps(a, b, _CMP_EQ_US);
940 }
941 
test_mm_cmp_ps_nge_uq(__m128 a,__m128 b)942 __m128 test_mm_cmp_ps_nge_uq(__m128 a, __m128 b) {
943   // CHECK-LABEL: test_mm_cmp_ps_nge_uq
944   // CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}}
945   return _mm_cmp_ps(a, b, _CMP_NGE_UQ);
946 }
947 
test_mm_cmp_ps_ngt_uq(__m128 a,__m128 b)948 __m128 test_mm_cmp_ps_ngt_uq(__m128 a, __m128 b) {
949   // CHECK-LABEL: test_mm_cmp_ps_ngt_uq
950   // CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}}
951   return _mm_cmp_ps(a, b, _CMP_NGT_UQ);
952 }
953 
test_mm_cmp_ps_false_os(__m128 a,__m128 b)954 __m128 test_mm_cmp_ps_false_os(__m128 a, __m128 b) {
955   // CHECK-LABEL: test_mm_cmp_ps_false_os
956   // CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}}
957   return _mm_cmp_ps(a, b, _CMP_FALSE_OS);
958 }
959 
test_mm_cmp_ps_neq_os(__m128 a,__m128 b)960 __m128 test_mm_cmp_ps_neq_os(__m128 a, __m128 b) {
961   // CHECK-LABEL: test_mm_cmp_ps_neq_os
962   // CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}}
963   return _mm_cmp_ps(a, b, _CMP_NEQ_OS);
964 }
965 
test_mm_cmp_ps_ge_oq(__m128 a,__m128 b)966 __m128 test_mm_cmp_ps_ge_oq(__m128 a, __m128 b) {
967   // CHECK-LABEL: test_mm_cmp_ps_ge_oq
968   // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
969   return _mm_cmp_ps(a, b, _CMP_GE_OQ);
970 }
971 
test_mm_cmp_ps_gt_oq(__m128 a,__m128 b)972 __m128 test_mm_cmp_ps_gt_oq(__m128 a, __m128 b) {
973   // CHECK-LABEL: test_mm_cmp_ps_gt_oq
974   // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
975   return _mm_cmp_ps(a, b, _CMP_GT_OQ);
976 }
977 
test_mm_cmp_ps_true_us(__m128 a,__m128 b)978 __m128 test_mm_cmp_ps_true_us(__m128 a, __m128 b) {
979   // CHECK-LABEL: test_mm_cmp_ps_true_us
980   // CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}}
981   return _mm_cmp_ps(a, b, _CMP_TRUE_US);
982 }
983 
test_mm_cmp_sd(__m128d A,__m128d B)984 __m128d test_mm_cmp_sd(__m128d A, __m128d B) {
985   // CHECK-LABEL: test_mm_cmp_sd
986   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 13)
987   return _mm_cmp_sd(A, B, _CMP_GE_OS);
988 }
989 
test_mm_cmp_ss(__m128 A,__m128 B)990 __m128 test_mm_cmp_ss(__m128 A, __m128 B) {
991   // CHECK-LABEL: test_mm_cmp_ss
992   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 13)
993   return _mm_cmp_ss(A, B, _CMP_GE_OS);
994 }
995 
test_mm256_cvtepi32_pd(__m128i A)996 __m256d test_mm256_cvtepi32_pd(__m128i A) {
997   // CHECK-LABEL: test_mm256_cvtepi32_pd
998   // CHECK: sitofp <4 x i32> %{{.*}} to <4 x double>
999   return _mm256_cvtepi32_pd(A);
1000 }
1001 
test_mm256_cvtepi32_ps(__m256i A)1002 __m256 test_mm256_cvtepi32_ps(__m256i A) {
1003   // CHECK-LABEL: test_mm256_cvtepi32_ps
1004   // CHECK: sitofp <8 x i32> %{{.*}} to <8 x float>
1005   return _mm256_cvtepi32_ps(A);
1006 }
1007 
test_mm256_cvtpd_epi32(__m256d A)1008 __m128i test_mm256_cvtpd_epi32(__m256d A) {
1009   // CHECK-LABEL: test_mm256_cvtpd_epi32
1010   // CHECK: call <4 x i32> @llvm.x86.avx.cvt.pd2dq.256(<4 x double> %{{.*}})
1011   return _mm256_cvtpd_epi32(A);
1012 }
1013 
test_mm256_cvtpd_ps(__m256d A)1014 __m128 test_mm256_cvtpd_ps(__m256d A) {
1015   // CHECK-LABEL: test_mm256_cvtpd_ps
1016   // CHECK: call <4 x float> @llvm.x86.avx.cvt.pd2.ps.256(<4 x double> %{{.*}})
1017   return _mm256_cvtpd_ps(A);
1018 }
1019 
test_mm256_cvtps_epi32(__m256 A)1020 __m256i test_mm256_cvtps_epi32(__m256 A) {
1021   // CHECK-LABEL: test_mm256_cvtps_epi32
1022   // CHECK: call <8 x i32> @llvm.x86.avx.cvt.ps2dq.256(<8 x float> %{{.*}})
1023   return _mm256_cvtps_epi32(A);
1024 }
1025 
test_mm256_cvtps_pd(__m128 A)1026 __m256d test_mm256_cvtps_pd(__m128 A) {
1027   // CHECK-LABEL: test_mm256_cvtps_pd
1028   // CHECK: fpext <4 x float> %{{.*}} to <4 x double>
1029   return _mm256_cvtps_pd(A);
1030 }
1031 
test_mm256_cvttpd_epi32(__m256d A)1032 __m128i test_mm256_cvttpd_epi32(__m256d A) {
1033   // CHECK-LABEL: test_mm256_cvttpd_epi32
1034   // CHECK: call <4 x i32> @llvm.x86.avx.cvtt.pd2dq.256(<4 x double> %{{.*}})
1035   return _mm256_cvttpd_epi32(A);
1036 }
1037 
test_mm256_cvttps_epi32(__m256 A)1038 __m256i test_mm256_cvttps_epi32(__m256 A) {
1039   // CHECK-LABEL: test_mm256_cvttps_epi32
1040   // CHECK: call <8 x i32> @llvm.x86.avx.cvtt.ps2dq.256(<8 x float> %{{.*}})
1041   return _mm256_cvttps_epi32(A);
1042 }
1043 
test_mm256_div_pd(__m256d A,__m256d B)1044 __m256d test_mm256_div_pd(__m256d A, __m256d B) {
1045   // CHECK-LABEL: test_mm256_div_pd
1046   // CHECK: fdiv <4 x double>
1047   return _mm256_div_pd(A, B);
1048 }
1049 
test_mm256_div_ps(__m256 A,__m256 B)1050 __m256 test_mm256_div_ps(__m256 A, __m256 B) {
1051   // CHECK-LABEL: test_mm256_div_ps
1052   // CHECK: fdiv <8 x float>
1053   return _mm256_div_ps(A, B);
1054 }
1055 
test_mm256_dp_ps(__m256 A,__m256 B)1056 __m256 test_mm256_dp_ps(__m256 A, __m256 B) {
1057   // CHECK-LABEL: test_mm256_dp_ps
1058   // CHECK: call <8 x float> @llvm.x86.avx.dp.ps.256(<8 x float> {{.*}}, <8 x float> {{.*}}, i8 7)
1059   return _mm256_dp_ps(A, B, 7);
1060 }
1061 
test_mm256_extract_epi8(__m256i A)1062 int test_mm256_extract_epi8(__m256i A) {
1063   // CHECK-LABEL: test_mm256_extract_epi8
1064   // CHECK: extractelement <32 x i8> %{{.*}}, {{i32|i64}} 31
1065   // CHECK: zext i8 %{{.*}} to i32
1066   return _mm256_extract_epi8(A, 31);
1067 }
1068 
test_mm256_extract_epi16(__m256i A)1069 int test_mm256_extract_epi16(__m256i A) {
1070   // CHECK-LABEL: test_mm256_extract_epi16
1071   // CHECK: extractelement <16 x i16> %{{.*}}, {{i32|i64}} 15
1072   // CHECK: zext i16 %{{.*}} to i32
1073   return _mm256_extract_epi16(A, 15);
1074 }
1075 
test_mm256_extract_epi32(__m256i A)1076 int test_mm256_extract_epi32(__m256i A) {
1077   // CHECK-LABEL: test_mm256_extract_epi32
1078   // CHECK: extractelement <8 x i32> %{{.*}}, {{i32|i64}} 7
1079   return _mm256_extract_epi32(A, 7);
1080 }
1081 
1082 #if __x86_64__
test_mm256_extract_epi64(__m256i A)1083 long long test_mm256_extract_epi64(__m256i A) {
1084   // CHECK-LABEL: test_mm256_extract_epi64
1085   // CHECK: extractelement <4 x i64> %{{.*}}, {{i32|i64}} 3
1086   return _mm256_extract_epi64(A, 3);
1087 }
1088 #endif
1089 
test_mm256_extractf128_pd(__m256d A)1090 __m128d test_mm256_extractf128_pd(__m256d A) {
1091   // CHECK-LABEL: test_mm256_extractf128_pd
1092   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <2 x i32> <i32 2, i32 3>
1093   return _mm256_extractf128_pd(A, 1);
1094 }
1095 
test_mm256_extractf128_ps(__m256 A)1096 __m128 test_mm256_extractf128_ps(__m256 A) {
1097   // CHECK-LABEL: test_mm256_extractf128_ps
1098   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1099   return _mm256_extractf128_ps(A, 1);
1100 }
1101 
test_mm256_extractf128_si256(__m256i A)1102 __m128i test_mm256_extractf128_si256(__m256i A) {
1103   // CHECK-LABEL: test_mm256_extractf128_si256
1104   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1105   return _mm256_extractf128_si256(A, 1);
1106 }
1107 
test_mm256_floor_pd(__m256d x)1108 __m256d test_mm256_floor_pd(__m256d x) {
1109   // CHECK-LABEL: test_mm256_floor_pd
1110   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 1)
1111   return _mm256_floor_pd(x);
1112 }
1113 
test_mm_floor_ps(__m256 x)1114 __m256 test_mm_floor_ps(__m256 x) {
1115   // CHECK-LABEL: test_mm_floor_ps
1116   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 1)
1117   return _mm256_floor_ps(x);
1118 }
1119 
test_mm256_hadd_pd(__m256d A,__m256d B)1120 __m256d test_mm256_hadd_pd(__m256d A, __m256d B) {
1121   // CHECK-LABEL: test_mm256_hadd_pd
1122   // CHECK: call <4 x double> @llvm.x86.avx.hadd.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1123   return _mm256_hadd_pd(A, B);
1124 }
1125 
test_mm256_hadd_ps(__m256 A,__m256 B)1126 __m256 test_mm256_hadd_ps(__m256 A, __m256 B) {
1127   // CHECK-LABEL: test_mm256_hadd_ps
1128   // CHECK: call <8 x float> @llvm.x86.avx.hadd.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1129   return _mm256_hadd_ps(A, B);
1130 }
1131 
test_mm256_hsub_pd(__m256d A,__m256d B)1132 __m256d test_mm256_hsub_pd(__m256d A, __m256d B) {
1133   // CHECK-LABEL: test_mm256_hsub_pd
1134   // CHECK: call <4 x double> @llvm.x86.avx.hsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1135   return _mm256_hsub_pd(A, B);
1136 }
1137 
test_mm256_hsub_ps(__m256 A,__m256 B)1138 __m256 test_mm256_hsub_ps(__m256 A, __m256 B) {
1139   // CHECK-LABEL: test_mm256_hsub_ps
1140   // CHECK: call <8 x float> @llvm.x86.avx.hsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1141   return _mm256_hsub_ps(A, B);
1142 }
1143 
test_mm256_insert_epi8(__m256i x,char b)1144 __m256i test_mm256_insert_epi8(__m256i x, char b) {
1145   // CHECK-LABEL: test_mm256_insert_epi8
1146   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, {{i32|i64}} 14
1147   return _mm256_insert_epi8(x, b, 14);
1148 }
1149 
test_mm256_insert_epi16(__m256i x,int b)1150 __m256i test_mm256_insert_epi16(__m256i x, int b) {
1151   // CHECK-LABEL: test_mm256_insert_epi16
1152   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, {{i32|i64}} 4
1153   return _mm256_insert_epi16(x, b, 4);
1154 }
1155 
test_mm256_insert_epi32(__m256i x,int b)1156 __m256i test_mm256_insert_epi32(__m256i x, int b) {
1157   // CHECK-LABEL: test_mm256_insert_epi32
1158   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, {{i32|i64}} 5
1159   return _mm256_insert_epi32(x, b, 5);
1160 }
1161 
1162 #if __x86_64__
test_mm256_insert_epi64(__m256i x,long long b)1163 __m256i test_mm256_insert_epi64(__m256i x, long long b) {
1164   // CHECK-LABEL: test_mm256_insert_epi64
1165   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, {{i32|i64}} 2
1166   return _mm256_insert_epi64(x, b, 2);
1167 }
1168 #endif
1169 
test_mm256_insertf128_pd(__m256d A,__m128d B)1170 __m256d test_mm256_insertf128_pd(__m256d A, __m128d B) {
1171   // CHECK-LABEL: test_mm256_insertf128_pd
1172   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1173   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
1174   return _mm256_insertf128_pd(A, B, 0);
1175 }
1176 
test_mm256_insertf128_ps(__m256 A,__m128 B)1177 __m256 test_mm256_insertf128_ps(__m256 A, __m128 B) {
1178   // CHECK-LABEL: test_mm256_insertf128_ps
1179   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1180   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
1181   return _mm256_insertf128_ps(A, B, 1);
1182 }
1183 
test_mm256_insertf128_si256(__m256i A,__m128i B)1184 __m256i test_mm256_insertf128_si256(__m256i A, __m128i B) {
1185   // CHECK-LABEL: test_mm256_insertf128_si256
1186   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1187   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 4, i32 5, i32 6, i32 7>
1188   return _mm256_insertf128_si256(A, B, 0);
1189 }
1190 
test_mm256_lddqu_si256(__m256i * A)1191 __m256i test_mm256_lddqu_si256(__m256i* A) {
1192   // CHECK-LABEL: test_mm256_lddqu_si256
1193   // CHECK: call <32 x i8> @llvm.x86.avx.ldu.dq.256(i8* %{{.*}})
1194   return _mm256_lddqu_si256(A);
1195 }
1196 
test_mm256_load_pd(double * A)1197 __m256d test_mm256_load_pd(double* A) {
1198   // CHECK-LABEL: test_mm256_load_pd
1199   // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 32
1200   return _mm256_load_pd(A);
1201 }
1202 
test_mm256_load_ps(float * A)1203 __m256 test_mm256_load_ps(float* A) {
1204   // CHECK-LABEL: test_mm256_load_ps
1205   // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 32
1206   return _mm256_load_ps(A);
1207 }
1208 
test_mm256_load_si256(__m256i * A)1209 __m256i test_mm256_load_si256(__m256i* A) {
1210   // CHECK-LABEL: test_mm256_load_si256
1211   // CHECK: load <4 x i64>, <4 x i64>* %{{.*}}, align 32
1212   return _mm256_load_si256(A);
1213 }
1214 
test_mm256_loadu_pd(double * A)1215 __m256d test_mm256_loadu_pd(double* A) {
1216   // CHECK-LABEL: test_mm256_loadu_pd
1217   // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 1{{$}}
1218   return _mm256_loadu_pd(A);
1219 }
1220 
test_mm256_loadu_ps(float * A)1221 __m256 test_mm256_loadu_ps(float* A) {
1222   // CHECK-LABEL: test_mm256_loadu_ps
1223   // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 1{{$}}
1224   return _mm256_loadu_ps(A);
1225 }
1226 
test_mm256_loadu_si256(__m256i * A)1227 __m256i test_mm256_loadu_si256(__m256i* A) {
1228   // CHECK-LABEL: test_mm256_loadu_si256
1229   // CHECK: load <4 x i64>, <4 x i64>* %{{.+}}, align 1{{$}}
1230   return _mm256_loadu_si256(A);
1231 }
1232 
test_mm256_loadu2_m128(float * A,float * B)1233 __m256 test_mm256_loadu2_m128(float* A, float* B) {
1234   // CHECK-LABEL: test_mm256_loadu2_m128
1235   // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
1236   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
1237   // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
1238   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1239   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
1240   return _mm256_loadu2_m128(A, B);
1241 }
1242 
test_mm256_loadu2_m128d(double * A,double * B)1243 __m256d test_mm256_loadu2_m128d(double* A, double* B) {
1244   // CHECK-LABEL: test_mm256_loadu2_m128d
1245   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
1246   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
1247   // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
1248   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1249   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1250   return _mm256_loadu2_m128d(A, B);
1251 }
1252 
test_mm256_loadu2_m128i(__m128i * A,__m128i * B)1253 __m256i test_mm256_loadu2_m128i(__m128i* A, __m128i* B) {
1254   // CHECK-LABEL: test_mm256_loadu2_m128i
1255   // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
1256   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
1257   // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
1258   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1259   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
1260   return _mm256_loadu2_m128i(A, B);
1261 }
1262 
test_mm_maskload_pd(double * A,__m128i B)1263 __m128d test_mm_maskload_pd(double* A, __m128i B) {
1264   // CHECK-LABEL: test_mm_maskload_pd
1265   // CHECK: call <2 x double> @llvm.x86.avx.maskload.pd(i8* %{{.*}}, <2 x i64> %{{.*}})
1266   return _mm_maskload_pd(A, B);
1267 }
1268 
test_mm256_maskload_pd(double * A,__m256i B)1269 __m256d test_mm256_maskload_pd(double* A, __m256i B) {
1270   // CHECK-LABEL: test_mm256_maskload_pd
1271   // CHECK: call <4 x double> @llvm.x86.avx.maskload.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}})
1272   return _mm256_maskload_pd(A, B);
1273 }
1274 
test_mm_maskload_ps(float * A,__m128i B)1275 __m128 test_mm_maskload_ps(float* A, __m128i B) {
1276   // CHECK-LABEL: test_mm_maskload_ps
1277   // CHECK: call <4 x float> @llvm.x86.avx.maskload.ps(i8* %{{.*}}, <4 x i32> %{{.*}})
1278   return _mm_maskload_ps(A, B);
1279 }
1280 
test_mm256_maskload_ps(float * A,__m256i B)1281 __m256 test_mm256_maskload_ps(float* A, __m256i B) {
1282   // CHECK-LABEL: test_mm256_maskload_ps
1283   // CHECK: call <8 x float> @llvm.x86.avx.maskload.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}})
1284   return _mm256_maskload_ps(A, B);
1285 }
1286 
test_mm_maskstore_pd(double * A,__m128i B,__m128d C)1287 void test_mm_maskstore_pd(double* A, __m128i B, __m128d C) {
1288   // CHECK-LABEL: test_mm_maskstore_pd
1289   // CHECK: call void @llvm.x86.avx.maskstore.pd(i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}})
1290   _mm_maskstore_pd(A, B, C);
1291 }
1292 
test_mm256_maskstore_pd(double * A,__m256i B,__m256d C)1293 void test_mm256_maskstore_pd(double* A, __m256i B, __m256d C) {
1294   // CHECK-LABEL: test_mm256_maskstore_pd
1295   // CHECK: call void @llvm.x86.avx.maskstore.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}})
1296   _mm256_maskstore_pd(A, B, C);
1297 }
1298 
test_mm_maskstore_ps(float * A,__m128i B,__m128 C)1299 void test_mm_maskstore_ps(float* A, __m128i B, __m128 C) {
1300   // CHECK-LABEL: test_mm_maskstore_ps
1301   // CHECK: call void @llvm.x86.avx.maskstore.ps(i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}})
1302   _mm_maskstore_ps(A, B, C);
1303 }
1304 
test_mm256_maskstore_ps(float * A,__m256i B,__m256 C)1305 void test_mm256_maskstore_ps(float* A, __m256i B, __m256 C) {
1306   // CHECK-LABEL: test_mm256_maskstore_ps
1307   // CHECK: call void @llvm.x86.avx.maskstore.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}})
1308   _mm256_maskstore_ps(A, B, C);
1309 }
1310 
test_mm256_max_pd(__m256d A,__m256d B)1311 __m256d test_mm256_max_pd(__m256d A, __m256d B) {
1312   // CHECK-LABEL: test_mm256_max_pd
1313   // CHECK: call <4 x double> @llvm.x86.avx.max.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1314   return _mm256_max_pd(A, B);
1315 }
1316 
test_mm256_max_ps(__m256 A,__m256 B)1317 __m256 test_mm256_max_ps(__m256 A, __m256 B) {
1318   // CHECK-LABEL: test_mm256_max_ps
1319   // CHECK: call <8 x float> @llvm.x86.avx.max.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1320   return _mm256_max_ps(A, B);
1321 }
1322 
test_mm256_min_pd(__m256d A,__m256d B)1323 __m256d test_mm256_min_pd(__m256d A, __m256d B) {
1324   // CHECK-LABEL: test_mm256_min_pd
1325   // CHECK: call <4 x double> @llvm.x86.avx.min.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1326   return _mm256_min_pd(A, B);
1327 }
1328 
test_mm256_min_ps(__m256 A,__m256 B)1329 __m256 test_mm256_min_ps(__m256 A, __m256 B) {
1330   // CHECK-LABEL: test_mm256_min_ps
1331   // CHECK: call <8 x float> @llvm.x86.avx.min.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1332   return _mm256_min_ps(A, B);
1333 }
1334 
test_mm256_movedup_pd(__m256d A)1335 __m256d test_mm256_movedup_pd(__m256d A) {
1336   // CHECK-LABEL: test_mm256_movedup_pd
1337   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
1338   return _mm256_movedup_pd(A);
1339 }
1340 
test_mm256_movehdup_ps(__m256 A)1341 __m256 test_mm256_movehdup_ps(__m256 A) {
1342   // CHECK-LABEL: test_mm256_movehdup_ps
1343   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 1, i32 1, i32 3, i32 3, i32 5, i32 5, i32 7, i32 7>
1344   return _mm256_movehdup_ps(A);
1345 }
1346 
test_mm256_moveldup_ps(__m256 A)1347 __m256 test_mm256_moveldup_ps(__m256 A) {
1348   // CHECK-LABEL: test_mm256_moveldup_ps
1349   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6>
1350   return _mm256_moveldup_ps(A);
1351 }
1352 
test_mm256_movemask_pd(__m256d A)1353 int test_mm256_movemask_pd(__m256d A) {
1354   // CHECK-LABEL: test_mm256_movemask_pd
1355   // CHECK: call i32 @llvm.x86.avx.movmsk.pd.256(<4 x double> %{{.*}})
1356   return _mm256_movemask_pd(A);
1357 }
1358 
test_mm256_movemask_ps(__m256 A)1359 int test_mm256_movemask_ps(__m256 A) {
1360   // CHECK-LABEL: test_mm256_movemask_ps
1361   // CHECK: call i32 @llvm.x86.avx.movmsk.ps.256(<8 x float> %{{.*}})
1362   return _mm256_movemask_ps(A);
1363 }
1364 
test_mm256_mul_pd(__m256d A,__m256d B)1365 __m256d test_mm256_mul_pd(__m256d A, __m256d B) {
1366   // CHECK-LABEL: test_mm256_mul_pd
1367   // CHECK: fmul <4 x double>
1368   return _mm256_mul_pd(A, B);
1369 }
1370 
test_mm256_mul_ps(__m256 A,__m256 B)1371 __m256 test_mm256_mul_ps(__m256 A, __m256 B) {
1372   // CHECK-LABEL: test_mm256_mul_ps
1373   // CHECK: fmul <8 x float>
1374   return _mm256_mul_ps(A, B);
1375 }
1376 
test_mm256_or_pd(__m256d A,__m256d B)1377 __m256d test_mm256_or_pd(__m256d A, __m256d B) {
1378   // CHECK-LABEL: test_mm256_or_pd
1379   // CHECK: or <4 x i64>
1380   return _mm256_or_pd(A, B);
1381 }
1382 
test_mm256_or_ps(__m256 A,__m256 B)1383 __m256 test_mm256_or_ps(__m256 A, __m256 B) {
1384   // CHECK-LABEL: test_mm256_or_ps
1385   // CHECK: or <8 x i32>
1386   return _mm256_or_ps(A, B);
1387 }
1388 
test_mm_permute_pd(__m128d A)1389 __m128d test_mm_permute_pd(__m128d A) {
1390   // CHECK-LABEL: test_mm_permute_pd
1391   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> poison, <2 x i32> <i32 1, i32 0>
1392   return _mm_permute_pd(A, 1);
1393 }
1394 
test_mm256_permute_pd(__m256d A)1395 __m256d test_mm256_permute_pd(__m256d A) {
1396   // CHECK-LABEL: test_mm256_permute_pd
1397   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
1398   return _mm256_permute_pd(A, 5);
1399 }
1400 
test_mm_permute_ps(__m128 A)1401 __m128 test_mm_permute_ps(__m128 A) {
1402   // CHECK-LABEL: test_mm_permute_ps
1403   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
1404   return _mm_permute_ps(A, 0x1b);
1405 }
1406 
1407 // Test case for PR12401
test2_mm_permute_ps(__m128 a)1408 __m128 test2_mm_permute_ps(__m128 a) {
1409   // CHECK-LABEL: test2_mm_permute_ps
1410   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> poison, <4 x i32> <i32 2, i32 1, i32 2, i32 3>
1411   return _mm_permute_ps(a, 0xe6);
1412 }
1413 
test_mm256_permute_ps(__m256 A)1414 __m256 test_mm256_permute_ps(__m256 A) {
1415   // CHECK-LABEL: test_mm256_permute_ps
1416   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> poison, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
1417   return _mm256_permute_ps(A, 0x1b);
1418 }
1419 
test_mm256_permute2f128_pd(__m256d A,__m256d B)1420 __m256d test_mm256_permute2f128_pd(__m256d A, __m256d B) {
1421   // CHECK-LABEL: test_mm256_permute2f128_pd
1422   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 2, i32 3, i32 6, i32 7>
1423   return _mm256_permute2f128_pd(A, B, 0x31);
1424 }
1425 
test_mm256_permute2f128_ps(__m256 A,__m256 B)1426 __m256 test_mm256_permute2f128_ps(__m256 A, __m256 B) {
1427   // CHECK-LABEL: test_mm256_permute2f128_ps
1428   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 4, i32 5, i32 6, i32 7, i32 12, i32 13, i32 14, i32 15>
1429   return _mm256_permute2f128_ps(A, B, 0x13);
1430 }
1431 
test_mm256_permute2f128_si256(__m256i A,__m256i B)1432 __m256i test_mm256_permute2f128_si256(__m256i A, __m256i B) {
1433   // CHECK-LABEL: test_mm256_permute2f128_si256
1434   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11>
1435   return _mm256_permute2f128_si256(A, B, 0x20);
1436 }
1437 
test_mm_permutevar_pd(__m128d A,__m128i B)1438 __m128d test_mm_permutevar_pd(__m128d A, __m128i B) {
1439   // CHECK-LABEL: test_mm_permutevar_pd
1440   // CHECK: call <2 x double> @llvm.x86.avx.vpermilvar.pd(<2 x double> %{{.*}}, <2 x i64> %{{.*}})
1441   return _mm_permutevar_pd(A, B);
1442 }
1443 
test_mm256_permutevar_pd(__m256d A,__m256i B)1444 __m256d test_mm256_permutevar_pd(__m256d A, __m256i B) {
1445   // CHECK-LABEL: test_mm256_permutevar_pd
1446   // CHECK: call <4 x double> @llvm.x86.avx.vpermilvar.pd.256(<4 x double> %{{.*}}, <4 x i64> %{{.*}})
1447   return _mm256_permutevar_pd(A, B);
1448 }
1449 
test_mm_permutevar_ps(__m128 A,__m128i B)1450 __m128 test_mm_permutevar_ps(__m128 A, __m128i B) {
1451   // CHECK-LABEL: test_mm_permutevar_ps
1452   // CHECK: call <4 x float> @llvm.x86.avx.vpermilvar.ps(<4 x float> %{{.*}}, <4 x i32> %{{.*}})
1453   return _mm_permutevar_ps(A, B);
1454 }
1455 
test_mm256_permutevar_ps(__m256 A,__m256i B)1456 __m256 test_mm256_permutevar_ps(__m256 A, __m256i B) {
1457   // CHECK-LABEL: test_mm256_permutevar_ps
1458   // CHECK: call <8 x float> @llvm.x86.avx.vpermilvar.ps.256(<8 x float> %{{.*}}, <8 x i32> %{{.*}})
1459   return _mm256_permutevar_ps(A, B);
1460 }
1461 
test_mm256_rcp_ps(__m256 A)1462 __m256 test_mm256_rcp_ps(__m256 A) {
1463   // CHECK-LABEL: test_mm256_rcp_ps
1464   // CHECK: call <8 x float> @llvm.x86.avx.rcp.ps.256(<8 x float> %{{.*}})
1465   return _mm256_rcp_ps(A);
1466 }
1467 
test_mm256_round_pd(__m256d x)1468 __m256d test_mm256_round_pd(__m256d x) {
1469   // CHECK-LABEL: test_mm256_round_pd
1470   // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 4)
1471   return _mm256_round_pd(x, 4);
1472 }
1473 
test_mm256_round_ps(__m256 x)1474 __m256 test_mm256_round_ps(__m256 x) {
1475   // CHECK-LABEL: test_mm256_round_ps
1476   // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 4)
1477   return _mm256_round_ps(x, 4);
1478 }
1479 
test_mm256_rsqrt_ps(__m256 A)1480 __m256 test_mm256_rsqrt_ps(__m256 A) {
1481   // CHECK-LABEL: test_mm256_rsqrt_ps
1482   // CHECK: call <8 x float> @llvm.x86.avx.rsqrt.ps.256(<8 x float> %{{.*}})
1483   return _mm256_rsqrt_ps(A);
1484 }
1485 
test_mm256_set_epi8(char A0,char A1,char A2,char A3,char A4,char A5,char A6,char A7,char A8,char A9,char A10,char A11,char A12,char A13,char A14,char A15,char A16,char A17,char A18,char A19,char A20,char A21,char A22,char A23,char A24,char A25,char A26,char A27,char A28,char A29,char A30,char A31)1486 __m256i test_mm256_set_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
1487                             char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
1488                             char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
1489                             char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
1490   // CHECK-LABEL: test_mm256_set_epi8
1491   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1492   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1493   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1494   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1495   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1496   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1497   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1498   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1499   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1500   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1501   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1502   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1503   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1504   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1505   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1506   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1507   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1508   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1509   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1510   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1511   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1512   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1513   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1514   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1515   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1516   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1517   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1518   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1519   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1520   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1521   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1522   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1523   return _mm256_set_epi8(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31);
1524 }
1525 
test_mm256_set_epi16(short A0,short A1,short A2,short A3,short A4,short A5,short A6,short A7,short A8,short A9,short A10,short A11,short A12,short A13,short A14,short A15)1526 __m256i test_mm256_set_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
1527                              short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
1528   // CHECK-LABEL: test_mm256_set_epi16
1529   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1530   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1531   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1532   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1533   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1534   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1535   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1536   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1537   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1538   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1539   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1540   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1541   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1542   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1543   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1544   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1545   return _mm256_set_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
1546 }
1547 
test_mm256_set_epi32(int A0,int A1,int A2,int A3,int A4,int A5,int A6,int A7)1548 __m256i test_mm256_set_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
1549   // CHECK-LABEL: test_mm256_set_epi32
1550   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1551   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1552   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1553   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1554   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1555   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1556   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1557   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1558   return _mm256_set_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
1559 }
1560 
test_mm256_set_epi64x(long long A0,long long A1,long long A2,long long A3)1561 __m256i test_mm256_set_epi64x(long long A0, long long A1, long long A2, long long A3) {
1562   // CHECK-LABEL: test_mm256_set_epi64x
1563   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1564   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1565   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1566   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1567   return _mm256_set_epi64x(A0, A1, A2, A3);
1568 }
1569 
test_mm256_set_m128(__m128 A,__m128 B)1570 __m256 test_mm256_set_m128(__m128 A, __m128 B) {
1571   // CHECK-LABEL: test_mm256_set_m128
1572   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1573   return _mm256_set_m128(A, B);
1574 }
1575 
test_mm256_set_m128d(__m128d A,__m128d B)1576 __m256d test_mm256_set_m128d(__m128d A, __m128d B) {
1577   // CHECK-LABEL: test_mm256_set_m128d
1578   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1579   return _mm256_set_m128d(A, B);
1580 }
1581 
test_mm256_set_m128i(__m128i A,__m128i B)1582 __m256i test_mm256_set_m128i(__m128i A, __m128i B) {
1583   // CHECK-LABEL: test_mm256_set_m128i
1584   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1585   return _mm256_set_m128i(A, B);
1586 }
1587 
test_mm256_set_pd(double A0,double A1,double A2,double A3)1588 __m256d test_mm256_set_pd(double A0, double A1, double A2, double A3) {
1589   // CHECK-LABEL: test_mm256_set_pd
1590   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1591   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1592   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1593   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1594   return _mm256_set_pd(A0, A1, A2, A3);
1595 }
1596 
test_mm256_set_ps(float A0,float A1,float A2,float A3,float A4,float A5,float A6,float A7)1597 __m256 test_mm256_set_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
1598   // CHECK-LABEL: test_mm256_set_ps
1599   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1600   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1601   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1602   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1603   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1604   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1605   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1606   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1607   return _mm256_set_ps(A0, A1, A2, A3, A4, A5, A6, A7);
1608 }
1609 
test_mm256_set1_epi8(char A)1610 __m256i test_mm256_set1_epi8(char A) {
1611   // CHECK-LABEL: test_mm256_set1_epi8
1612   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1613   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1614   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1615   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1616   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1617   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1618   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1619   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1620   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1621   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1622   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1623   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1624   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1625   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1626   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1627   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1628   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1629   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1630   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1631   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1632   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1633   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1634   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1635   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1636   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1637   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1638   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1639   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1640   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1641   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1642   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1643   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1644   return _mm256_set1_epi8(A);
1645 }
1646 
test_mm256_set1_epi16(short A)1647 __m256i test_mm256_set1_epi16(short A) {
1648   // CHECK-LABEL: test_mm256_set1_epi16
1649   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1650   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1651   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1652   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1653   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1654   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1655   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1656   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1657   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1658   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1659   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1660   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1661   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1662   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1663   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1664   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1665   return _mm256_set1_epi16(A);
1666 }
1667 
test_mm256_set1_epi32(int A)1668 __m256i test_mm256_set1_epi32(int A) {
1669   // CHECK-LABEL: test_mm256_set1_epi32
1670   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1671   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1672   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1673   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1674   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1675   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1676   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1677   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1678   return _mm256_set1_epi32(A);
1679 }
1680 
test_mm256_set1_epi64x(long long A)1681 __m256i test_mm256_set1_epi64x(long long A) {
1682   // CHECK-LABEL: test_mm256_set1_epi64x
1683   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1684   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1685   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1686   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1687   return _mm256_set1_epi64x(A);
1688 }
1689 
test_mm256_set1_pd(double A)1690 __m256d test_mm256_set1_pd(double A) {
1691   // CHECK-LABEL: test_mm256_set1_pd
1692   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1693   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1694   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1695   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1696   return _mm256_set1_pd(A);
1697 }
1698 
test_mm256_set1_ps(float A)1699 __m256 test_mm256_set1_ps(float A) {
1700   // CHECK-LABEL: test_mm256_set1_ps
1701   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1702   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1703   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1704   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1705   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1706   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1707   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1708   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1709   return _mm256_set1_ps(A);
1710 }
1711 
test_mm256_setr_epi8(char A0,char A1,char A2,char A3,char A4,char A5,char A6,char A7,char A8,char A9,char A10,char A11,char A12,char A13,char A14,char A15,char A16,char A17,char A18,char A19,char A20,char A21,char A22,char A23,char A24,char A25,char A26,char A27,char A28,char A29,char A30,char A31)1712 __m256i test_mm256_setr_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
1713                              char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
1714                              char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
1715                              char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
1716   // CHECK-LABEL: test_mm256_setr_epi8
1717   // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1718   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1719   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1720   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1721   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1722   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1723   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1724   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1725   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1726   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1727   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1728   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1729   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1730   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1731   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1732   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1733   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1734   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1735   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1736   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1737   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1738   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1739   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1740   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1741   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1742   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1743   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1744   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1745   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1746   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1747   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1748   // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1749   return _mm256_setr_epi8(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31);
1750 }
1751 
test_mm256_setr_epi16(short A0,short A1,short A2,short A3,short A4,short A5,short A6,short A7,short A8,short A9,short A10,short A11,short A12,short A13,short A14,short A15)1752 __m256i test_mm256_setr_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
1753                               short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
1754   // CHECK-LABEL: test_mm256_setr_epi16
1755   // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1756   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1757   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1758   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1759   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1760   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1761   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1762   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1763   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1764   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1765   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1766   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1767   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1768   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1769   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1770   // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1771   return _mm256_setr_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
1772 }
1773 
test_mm256_setr_epi32(int A0,int A1,int A2,int A3,int A4,int A5,int A6,int A7)1774 __m256i test_mm256_setr_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
1775   // CHECK-LABEL: test_mm256_setr_epi32
1776   // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1777   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1778   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1779   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1780   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1781   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1782   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1783   // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1784   return _mm256_setr_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
1785 }
1786 
test_mm256_setr_epi64x(long long A0,long long A1,long long A2,long long A3)1787 __m256i test_mm256_setr_epi64x(long long A0, long long A1, long long A2, long long A3) {
1788   // CHECK-LABEL: test_mm256_setr_epi64x
1789   // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1790   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1791   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1792   // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1793   return _mm256_setr_epi64x(A0, A1, A2, A3);
1794 }
1795 
test_mm256_setr_m128(__m128 A,__m128 B)1796 __m256 test_mm256_setr_m128(__m128 A, __m128 B) {
1797   // CHECK-LABEL: test_mm256_setr_m128
1798   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1799   return _mm256_setr_m128(A, B);
1800 }
1801 
test_mm256_setr_m128d(__m128d A,__m128d B)1802 __m256d test_mm256_setr_m128d(__m128d A, __m128d B) {
1803   // CHECK-LABEL: test_mm256_setr_m128d
1804   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1805   return _mm256_setr_m128d(A, B);
1806 }
1807 
test_mm256_setr_m128i(__m128i A,__m128i B)1808 __m256i test_mm256_setr_m128i(__m128i A, __m128i B) {
1809   // CHECK-LABEL: test_mm256_setr_m128i
1810   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1811   return _mm256_setr_m128i(A, B);
1812 }
1813 
test_mm256_setr_pd(double A0,double A1,double A2,double A3)1814 __m256d test_mm256_setr_pd(double A0, double A1, double A2, double A3) {
1815   // CHECK-LABEL: test_mm256_setr_pd
1816   // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1817   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1818   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1819   // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1820   return _mm256_setr_pd(A0, A1, A2, A3);
1821 }
1822 
test_mm256_setr_ps(float A0,float A1,float A2,float A3,float A4,float A5,float A6,float A7)1823 __m256 test_mm256_setr_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
1824   // CHECK-LABEL: test_mm256_setr_ps
1825   // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1826   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1827   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1828   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1829   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1830   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1831   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1832   // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1833   return _mm256_setr_ps(A0, A1, A2, A3, A4, A5, A6, A7);
1834 }
1835 
test_mm256_setzero_pd()1836 __m256d test_mm256_setzero_pd() {
1837   // CHECK-LABEL: test_mm256_setzero_pd
1838   // CHECK: store <4 x double> zeroinitializer
1839   return _mm256_setzero_pd();
1840 }
1841 
test_mm256_setzero_ps()1842 __m256 test_mm256_setzero_ps() {
1843   // CHECK-LABEL: test_mm256_setzero_ps
1844   // CHECK: store <8 x float> zeroinitializer
1845   return _mm256_setzero_ps();
1846 }
1847 
test_mm256_setzero_si256()1848 __m256i test_mm256_setzero_si256() {
1849   // CHECK-LABEL: test_mm256_setzero_si256
1850   // CHECK: store <4 x i64> zeroinitializer
1851   return _mm256_setzero_si256();
1852 }
1853 
test_mm256_shuffle_pd(__m256d A,__m256d B)1854 __m256d test_mm256_shuffle_pd(__m256d A, __m256d B) {
1855   // CHECK-LABEL: test_mm256_shuffle_pd
1856   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1857   return _mm256_shuffle_pd(A, B, 0);
1858 }
1859 
test_mm256_shuffle_ps(__m256 A,__m256 B)1860 __m256 test_mm256_shuffle_ps(__m256 A, __m256 B) {
1861   // CHECK-LABEL: test_mm256_shuffle_ps
1862   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 8, i32 8, i32 4, i32 4, i32 12, i32 12>
1863   return _mm256_shuffle_ps(A, B, 0);
1864 }
1865 
test_mm256_sqrt_pd(__m256d A)1866 __m256d test_mm256_sqrt_pd(__m256d A) {
1867   // CHECK-LABEL: test_mm256_sqrt_pd
1868   // CHECK: call <4 x double> @llvm.sqrt.v4f64(<4 x double> %{{.*}})
1869   return _mm256_sqrt_pd(A);
1870 }
1871 
test_mm256_sqrt_ps(__m256 A)1872 __m256 test_mm256_sqrt_ps(__m256 A) {
1873   // CHECK-LABEL: test_mm256_sqrt_ps
1874   // CHECK: call <8 x float> @llvm.sqrt.v8f32(<8 x float> %{{.*}})
1875   return _mm256_sqrt_ps(A);
1876 }
1877 
test_mm256_store_pd(double * A,__m256d B)1878 void test_mm256_store_pd(double* A, __m256d B) {
1879   // CHECK-LABEL: test_mm256_store_pd
1880   // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32
1881   _mm256_store_pd(A, B);
1882 }
1883 
test_mm256_store_ps(float * A,__m256 B)1884 void test_mm256_store_ps(float* A, __m256 B) {
1885   // CHECK-LABEL: test_mm256_store_ps
1886   // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32
1887   _mm256_store_ps(A, B);
1888 }
1889 
test_mm256_store_si256(__m256i * A,__m256i B)1890 void test_mm256_store_si256(__m256i* A, __m256i B) {
1891   // CHECK-LABEL: test_mm256_store_si256
1892   // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32
1893   _mm256_store_si256(A, B);
1894 }
1895 
test_mm256_storeu_pd(double * A,__m256d B)1896 void test_mm256_storeu_pd(double* A, __m256d B) {
1897   // CHECK-LABEL: test_mm256_storeu_pd
1898   // CHECK:   store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 1{{$}}
1899   // CHECK-NEXT: ret void
1900   _mm256_storeu_pd(A, B);
1901 }
1902 
test_mm256_storeu_ps(float * A,__m256 B)1903 void test_mm256_storeu_ps(float* A, __m256 B) {
1904   // CHECK-LABEL: test_mm256_storeu_ps
1905   // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 1{{$}}
1906   // CHECk-NEXT: ret void
1907   _mm256_storeu_ps(A, B);
1908 }
1909 
test_mm256_storeu_si256(__m256i * A,__m256i B)1910 void test_mm256_storeu_si256(__m256i* A, __m256i B) {
1911   // CHECK-LABEL: test_mm256_storeu_si256
1912   // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 1{{$}}
1913   // CHECk-NEXT: ret void
1914   _mm256_storeu_si256(A, B);
1915 }
1916 
test_mm256_storeu2_m128(float * A,float * B,__m256 C)1917 void test_mm256_storeu2_m128(float* A, float* B, __m256 C) {
1918   // CHECK-LABEL: test_mm256_storeu2_m128
1919   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1920   // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}}
1921   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1922   // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}}
1923   _mm256_storeu2_m128(A, B, C);
1924 }
1925 
test_mm256_storeu2_m128d(double * A,double * B,__m256d C)1926 void test_mm256_storeu2_m128d(double* A, double* B, __m256d C) {
1927   // CHECK-LABEL: test_mm256_storeu2_m128d
1928   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1>
1929   // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}}
1930   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <2 x i32> <i32 2, i32 3>
1931   // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}}
1932   _mm256_storeu2_m128d(A, B, C);
1933 }
1934 
test_mm256_storeu2_m128i(__m128i * A,__m128i * B,__m256i C)1935 void test_mm256_storeu2_m128i(__m128i* A, __m128i* B, __m256i C) {
1936   // CHECK-LABEL: test_mm256_storeu2_m128i
1937   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1>
1938   // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
1939   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1940   // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
1941   _mm256_storeu2_m128i(A, B, C);
1942 }
1943 
test_mm256_stream_pd(double * A,__m256d B)1944 void test_mm256_stream_pd(double* A, __m256d B) {
1945   // CHECK-LABEL: test_mm256_stream_pd
1946   // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32, !nontemporal
1947   _mm256_stream_pd(A, B);
1948 }
1949 
test_mm256_stream_ps(float * A,__m256 B)1950 void test_mm256_stream_ps(float* A, __m256 B) {
1951   // CHECK-LABEL: test_mm256_stream_ps
1952   // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32, !nontemporal
1953   _mm256_stream_ps(A, B);
1954 }
1955 
test_mm256_stream_si256(__m256i * A,__m256i B)1956 void test_mm256_stream_si256(__m256i* A, __m256i B) {
1957   // CHECK-LABEL: test_mm256_stream_si256
1958   // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32, !nontemporal
1959   _mm256_stream_si256(A, B);
1960 }
1961 
test_mm256_sub_pd(__m256d A,__m256d B)1962 __m256d test_mm256_sub_pd(__m256d A, __m256d B) {
1963   // CHECK-LABEL: test_mm256_sub_pd
1964   // CHECK: fsub <4 x double>
1965   return _mm256_sub_pd(A, B);
1966 }
1967 
test_mm256_sub_ps(__m256 A,__m256 B)1968 __m256 test_mm256_sub_ps(__m256 A, __m256 B) {
1969   // CHECK-LABEL: test_mm256_sub_ps
1970   // CHECK: fsub <8 x float>
1971   return _mm256_sub_ps(A, B);
1972 }
1973 
test_mm_testc_pd(__m128d A,__m128d B)1974 int test_mm_testc_pd(__m128d A, __m128d B) {
1975   // CHECK-LABEL: test_mm_testc_pd
1976   // CHECK: call i32 @llvm.x86.avx.vtestc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1977   return _mm_testc_pd(A, B);
1978 }
1979 
test_mm256_testc_pd(__m256d A,__m256d B)1980 int test_mm256_testc_pd(__m256d A, __m256d B) {
1981   // CHECK-LABEL: test_mm256_testc_pd
1982   // CHECK: call i32 @llvm.x86.avx.vtestc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1983   return _mm256_testc_pd(A, B);
1984 }
1985 
test_mm_testc_ps(__m128 A,__m128 B)1986 int test_mm_testc_ps(__m128 A, __m128 B) {
1987   // CHECK-LABEL: test_mm_testc_ps
1988   // CHECK: call i32 @llvm.x86.avx.vtestc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
1989   return _mm_testc_ps(A, B);
1990 }
1991 
test_mm256_testc_ps(__m256 A,__m256 B)1992 int test_mm256_testc_ps(__m256 A, __m256 B) {
1993   // CHECK-LABEL: test_mm256_testc_ps
1994   // CHECK: call i32 @llvm.x86.avx.vtestc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1995   return _mm256_testc_ps(A, B);
1996 }
1997 
test_mm256_testc_si256(__m256i A,__m256i B)1998 int test_mm256_testc_si256(__m256i A, __m256i B) {
1999   // CHECK-LABEL: test_mm256_testc_si256
2000   // CHECK: call i32 @llvm.x86.avx.ptestc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2001   return _mm256_testc_si256(A, B);
2002 }
2003 
test_mm_testnzc_pd(__m128d A,__m128d B)2004 int test_mm_testnzc_pd(__m128d A, __m128d B) {
2005   // CHECK-LABEL: test_mm_testnzc_pd
2006   // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2007   return _mm_testnzc_pd(A, B);
2008 }
2009 
test_mm256_testnzc_pd(__m256d A,__m256d B)2010 int test_mm256_testnzc_pd(__m256d A, __m256d B) {
2011   // CHECK-LABEL: test_mm256_testnzc_pd
2012   // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
2013   return _mm256_testnzc_pd(A, B);
2014 }
2015 
test_mm_testnzc_ps(__m128 A,__m128 B)2016 int test_mm_testnzc_ps(__m128 A, __m128 B) {
2017   // CHECK-LABEL: test_mm_testnzc_ps
2018   // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
2019   return _mm_testnzc_ps(A, B);
2020 }
2021 
test_mm256_testnzc_ps(__m256 A,__m256 B)2022 int test_mm256_testnzc_ps(__m256 A, __m256 B) {
2023   // CHECK-LABEL: test_mm256_testnzc_ps
2024   // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
2025   return _mm256_testnzc_ps(A, B);
2026 }
2027 
test_mm256_testnzc_si256(__m256i A,__m256i B)2028 int test_mm256_testnzc_si256(__m256i A, __m256i B) {
2029   // CHECK-LABEL: test_mm256_testnzc_si256
2030   // CHECK: call i32 @llvm.x86.avx.ptestnzc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2031   return _mm256_testnzc_si256(A, B);
2032 }
2033 
test_mm_testz_pd(__m128d A,__m128d B)2034 int test_mm_testz_pd(__m128d A, __m128d B) {
2035   // CHECK-LABEL: test_mm_testz_pd
2036   // CHECK: call i32 @llvm.x86.avx.vtestz.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2037   return _mm_testz_pd(A, B);
2038 }
2039 
test_mm256_testz_pd(__m256d A,__m256d B)2040 int test_mm256_testz_pd(__m256d A, __m256d B) {
2041   // CHECK-LABEL: test_mm256_testz_pd
2042   // CHECK: call i32 @llvm.x86.avx.vtestz.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
2043   return _mm256_testz_pd(A, B);
2044 }
2045 
test_mm_testz_ps(__m128 A,__m128 B)2046 int test_mm_testz_ps(__m128 A, __m128 B) {
2047   // CHECK-LABEL: test_mm_testz_ps
2048   // CHECK: call i32 @llvm.x86.avx.vtestz.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
2049   return _mm_testz_ps(A, B);
2050 }
2051 
test_mm256_testz_ps(__m256 A,__m256 B)2052 int test_mm256_testz_ps(__m256 A, __m256 B) {
2053   // CHECK-LABEL: test_mm256_testz_ps
2054   // CHECK: call i32 @llvm.x86.avx.vtestz.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
2055   return _mm256_testz_ps(A, B);
2056 }
2057 
test_mm256_testz_si256(__m256i A,__m256i B)2058 int test_mm256_testz_si256(__m256i A, __m256i B) {
2059   // CHECK-LABEL: test_mm256_testz_si256
2060   // CHECK: call i32 @llvm.x86.avx.ptestz.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2061   return _mm256_testz_si256(A, B);
2062 }
2063 
test_mm256_undefined_ps()2064 __m256 test_mm256_undefined_ps() {
2065   // CHECK-LABEL: test_mm256_undefined_ps
2066   // CHECK: ret <8 x float> zeroinitializer
2067   return _mm256_undefined_ps();
2068 }
2069 
test_mm256_undefined_pd()2070 __m256d test_mm256_undefined_pd() {
2071   // CHECK-LABEL: test_mm256_undefined_pd
2072   // CHECK: ret <4 x double> zeroinitializer
2073   return _mm256_undefined_pd();
2074 }
2075 
test_mm256_undefined_si256()2076 __m256i test_mm256_undefined_si256() {
2077   // CHECK-LABEL: test_mm256_undefined_si256
2078   // CHECK: ret <4 x i64> zeroinitializer
2079   return _mm256_undefined_si256();
2080 }
2081 
test_mm256_unpackhi_pd(__m256d A,__m256d B)2082 __m256d test_mm256_unpackhi_pd(__m256d A, __m256d B) {
2083   // CHECK-LABEL: test_mm256_unpackhi_pd
2084   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
2085   return _mm256_unpackhi_pd(A, B);
2086 }
2087 
test_mm256_unpackhi_ps(__m256 A,__m256 B)2088 __m256 test_mm256_unpackhi_ps(__m256 A, __m256 B) {
2089   // CHECK-LABEL: test_mm256_unpackhi_ps
2090   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 2, i32 10, i32 3, i32 11, i32 6, i32 14, i32 7, i32 15>
2091   return _mm256_unpackhi_ps(A, B);
2092 }
2093 
test_mm256_unpacklo_pd(__m256d A,__m256d B)2094 __m256d test_mm256_unpacklo_pd(__m256d A, __m256d B) {
2095   // CHECK-LABEL: test_mm256_unpacklo_pd
2096   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
2097   return _mm256_unpacklo_pd(A, B);
2098 }
2099 
test_mm256_unpacklo_ps(__m256 A,__m256 B)2100 __m256 test_mm256_unpacklo_ps(__m256 A, __m256 B) {
2101   // CHECK-LABEL: test_mm256_unpacklo_ps
2102   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 4, i32 12, i32 5, i32 13>
2103   return _mm256_unpacklo_ps(A, B);
2104 }
2105 
test_mm256_xor_pd(__m256d A,__m256d B)2106 __m256d test_mm256_xor_pd(__m256d A, __m256d B) {
2107   // CHECK-LABEL: test_mm256_xor_pd
2108   // CHECK: xor <4 x i64>
2109   return _mm256_xor_pd(A, B);
2110 }
2111 
test_mm256_xor_ps(__m256 A,__m256 B)2112 __m256 test_mm256_xor_ps(__m256 A, __m256 B) {
2113   // CHECK-LABEL: test_mm256_xor_ps
2114   // CHECK: xor <8 x i32>
2115   return _mm256_xor_ps(A, B);
2116 }
2117 
test_mm256_zeroall()2118 void test_mm256_zeroall() {
2119   // CHECK-LABEL: test_mm256_zeroall
2120   // CHECK: call void @llvm.x86.avx.vzeroall()
2121   return _mm256_zeroall();
2122 }
2123 
test_mm256_zeroupper()2124 void test_mm256_zeroupper() {
2125   // CHECK-LABEL: test_mm256_zeroupper
2126   // CHECK: call void @llvm.x86.avx.vzeroupper()
2127   return _mm256_zeroupper();
2128 }
2129 
test_mm256_zextpd128_pd256(__m128d A)2130 __m256d test_mm256_zextpd128_pd256(__m128d A) {
2131   // CHECK-LABEL: test_mm256_zextpd128_pd256
2132   // CHECK: store <2 x double> zeroinitializer
2133   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2134   return _mm256_zextpd128_pd256(A);
2135 }
2136 
test_mm256_zextps128_ps256(__m128 A)2137 __m256 test_mm256_zextps128_ps256(__m128 A) {
2138   // CHECK-LABEL: test_mm256_zextps128_ps256
2139   // CHECK: store <4 x float> zeroinitializer
2140   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
2141   return _mm256_zextps128_ps256(A);
2142 }
2143 
test_mm256_zextsi128_si256(__m128i A)2144 __m256i test_mm256_zextsi128_si256(__m128i A) {
2145   // CHECK-LABEL: test_mm256_zextsi128_si256
2146   // CHECK: store <2 x i64> zeroinitializer
2147   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2148   return _mm256_zextsi128_si256(A);
2149 }
2150 
test_mm256_cvtsd_f64(__m256d __a)2151 double test_mm256_cvtsd_f64(__m256d __a)
2152 {
2153   // CHECK-LABEL: test_mm256_cvtsd_f64
2154   // CHECK: extractelement <4 x double> %{{.*}}, i32 0
2155   return _mm256_cvtsd_f64(__a);
2156 }
2157 
test_mm256_cvtsi256_si32(__m256i __a)2158 int test_mm256_cvtsi256_si32(__m256i __a)
2159 {
2160   // CHECK-LABEL: test_mm256_cvtsi256_si32
2161   // CHECK: extractelement <8 x i32> %{{.*}}, i32 0
2162   return _mm256_cvtsi256_si32(__a);
2163 }
2164 
test_mm256_cvtss_f32(__m256 __a)2165 float test_mm256_cvtss_f32(__m256 __a)
2166 {
2167   // CHECK-LABEL: test_mm256_cvtss_f32
2168   // CHECK: extractelement <8 x float> %{{.*}}, i32 0
2169   return _mm256_cvtss_f32(__a);
2170 }
2171