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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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