Clang Project

clang_source_code/test/CodeGen/avx-builtins.c
1// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s
2// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s
3// RUN: %clang_cc1 -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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
108__m128d 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
118__m256d 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1062int 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
1069int 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
1076int 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
1082long long test_mm256_extract_epi64(__m256i A) {
1083  // CHECK-LABEL: test_mm256_extract_epi64
1084  // CHECK: extractelement <4 x i64> %{{.*}}, {{i32|i64}} 3
1085  return _mm256_extract_epi64(A, 3);
1086}
1087
1088__m128d test_mm256_extractf128_pd(__m256d A) {
1089  // CHECK-LABEL: test_mm256_extractf128_pd
1090  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3>
1091  return _mm256_extractf128_pd(A, 1);
1092}
1093
1094__m128 test_mm256_extractf128_ps(__m256 A) {
1095  // CHECK-LABEL: test_mm256_extractf128_ps
1096  // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1097  return _mm256_extractf128_ps(A, 1);
1098}
1099
1100__m128i test_mm256_extractf128_si256(__m256i A) {
1101  // CHECK-LABEL: test_mm256_extractf128_si256
1102  // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1103  return _mm256_extractf128_si256(A, 1);
1104}
1105
1106__m256d test_mm256_floor_pd(__m256d x) {
1107  // CHECK-LABEL: test_mm256_floor_pd
1108  // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 1)
1109  return _mm256_floor_pd(x);
1110}
1111
1112__m256 test_mm_floor_ps(__m256 x) {
1113  // CHECK-LABEL: test_mm_floor_ps
1114  // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 1)
1115  return _mm256_floor_ps(x);
1116}
1117
1118__m256d test_mm256_hadd_pd(__m256d A, __m256d B) {
1119  // CHECK-LABEL: test_mm256_hadd_pd
1120  // CHECK: call <4 x double> @llvm.x86.avx.hadd.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1121  return _mm256_hadd_pd(A, B);
1122}
1123
1124__m256 test_mm256_hadd_ps(__m256 A, __m256 B) {
1125  // CHECK-LABEL: test_mm256_hadd_ps
1126  // CHECK: call <8 x float> @llvm.x86.avx.hadd.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1127  return _mm256_hadd_ps(A, B);
1128}
1129
1130__m256d test_mm256_hsub_pd(__m256d A, __m256d B) {
1131  // CHECK-LABEL: test_mm256_hsub_pd
1132  // CHECK: call <4 x double> @llvm.x86.avx.hsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1133  return _mm256_hsub_pd(A, B);
1134}
1135
1136__m256 test_mm256_hsub_ps(__m256 A, __m256 B) {
1137  // CHECK-LABEL: test_mm256_hsub_ps
1138  // CHECK: call <8 x float> @llvm.x86.avx.hsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1139  return _mm256_hsub_ps(A, B);
1140}
1141
1142__m256i test_mm256_insert_epi8(__m256i x, char b) {
1143  // CHECK-LABEL: test_mm256_insert_epi8
1144  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, {{i32|i64}} 14
1145  return _mm256_insert_epi8(x, b, 14);
1146}
1147
1148__m256i test_mm256_insert_epi16(__m256i x, int b) {
1149  // CHECK-LABEL: test_mm256_insert_epi16
1150  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, {{i32|i64}} 4
1151  return _mm256_insert_epi16(x, b, 4);
1152}
1153
1154__m256i test_mm256_insert_epi32(__m256i x, int b) {
1155  // CHECK-LABEL: test_mm256_insert_epi32
1156  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, {{i32|i64}} 5
1157  return _mm256_insert_epi32(x, b, 5);
1158}
1159
1160__m256i test_mm256_insert_epi64(__m256i x, long long b) {
1161  // CHECK-LABEL: test_mm256_insert_epi64
1162  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, {{i32|i64}} 2
1163  return _mm256_insert_epi64(x, b, 2);
1164}
1165
1166__m256d test_mm256_insertf128_pd(__m256d A, __m128d B) {
1167  // CHECK-LABEL: test_mm256_insertf128_pd
1168  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1169  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
1170  return _mm256_insertf128_pd(A, B, 0);
1171}
1172
1173__m256 test_mm256_insertf128_ps(__m256 A, __m128 B) {
1174  // CHECK-LABEL: test_mm256_insertf128_ps
1175  // 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>
1176  // 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>
1177  return _mm256_insertf128_ps(A, B, 1);
1178}
1179
1180__m256i test_mm256_insertf128_si256(__m256i A, __m128i B) {
1181  // CHECK-LABEL: test_mm256_insertf128_si256
1182  // 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>
1183  // 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>
1184  return _mm256_insertf128_si256(A, B, 0);
1185}
1186
1187__m256i test_mm256_lddqu_si256(__m256i* A) {
1188  // CHECK-LABEL: test_mm256_lddqu_si256
1189  // CHECK: call <32 x i8> @llvm.x86.avx.ldu.dq.256(i8* %{{.*}})
1190  return _mm256_lddqu_si256(A);
1191}
1192
1193__m256d test_mm256_load_pd(double* A) {
1194  // CHECK-LABEL: test_mm256_load_pd
1195  // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 32
1196  return _mm256_load_pd(A);
1197}
1198
1199__m256 test_mm256_load_ps(float* A) {
1200  // CHECK-LABEL: test_mm256_load_ps
1201  // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 32
1202  return _mm256_load_ps(A);
1203}
1204
1205__m256i test_mm256_load_si256(__m256i* A) {
1206  // CHECK-LABEL: test_mm256_load_si256
1207  // CHECK: load <4 x i64>, <4 x i64>* %{{.*}}, align 32
1208  return _mm256_load_si256(A);
1209}
1210
1211__m256d test_mm256_loadu_pd(double* A) {
1212  // CHECK-LABEL: test_mm256_loadu_pd
1213  // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 1{{$}}
1214  return _mm256_loadu_pd(A);
1215}
1216
1217__m256 test_mm256_loadu_ps(float* A) {
1218  // CHECK-LABEL: test_mm256_loadu_ps
1219  // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 1{{$}}
1220  return _mm256_loadu_ps(A);
1221}
1222
1223__m256i test_mm256_loadu_si256(__m256i* A) {
1224  // CHECK-LABEL: test_mm256_loadu_si256
1225  // CHECK: load <4 x i64>, <4 x i64>* %{{.+}}, align 1{{$}}
1226  return _mm256_loadu_si256(A);
1227}
1228
1229__m256 test_mm256_loadu2_m128(float* A, float* B) {
1230  // CHECK-LABEL: test_mm256_loadu2_m128
1231  // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
1232  // 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>
1233  // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}}
1234  // 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>
1235  // 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>
1236  return _mm256_loadu2_m128(A, B);
1237}
1238
1239__m256d test_mm256_loadu2_m128d(double* A, double* B) {
1240  // CHECK-LABEL: test_mm256_loadu2_m128d
1241  // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
1242  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
1243  // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}}
1244  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1245  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1246  return _mm256_loadu2_m128d(A, B);
1247}
1248
1249__m256i test_mm256_loadu2_m128i(__m128i* A, __m128i* B) {
1250  // CHECK-LABEL: test_mm256_loadu2_m128i
1251  // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
1252  // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
1253  // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}}
1254  // 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>
1255  // 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>
1256  return _mm256_loadu2_m128i(A, B);
1257}
1258
1259__m128d test_mm_maskload_pd(double* A, __m128i B) {
1260  // CHECK-LABEL: test_mm_maskload_pd
1261  // CHECK: call <2 x double> @llvm.x86.avx.maskload.pd(i8* %{{.*}}, <2 x i64> %{{.*}})
1262  return _mm_maskload_pd(A, B);
1263}
1264
1265__m256d test_mm256_maskload_pd(double* A, __m256i B) {
1266  // CHECK-LABEL: test_mm256_maskload_pd
1267  // CHECK: call <4 x double> @llvm.x86.avx.maskload.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}})
1268  return _mm256_maskload_pd(A, B);
1269}
1270
1271__m128 test_mm_maskload_ps(float* A, __m128i B) {
1272  // CHECK-LABEL: test_mm_maskload_ps
1273  // CHECK: call <4 x float> @llvm.x86.avx.maskload.ps(i8* %{{.*}}, <4 x i32> %{{.*}})
1274  return _mm_maskload_ps(A, B);
1275}
1276
1277__m256d test_mm256_maskload_ps(float* A, __m256i B) {
1278  // CHECK-LABEL: test_mm256_maskload_ps
1279  // CHECK: call <8 x float> @llvm.x86.avx.maskload.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}})
1280  return _mm256_maskload_ps(A, B);
1281}
1282
1283void test_mm_maskstore_pd(double* A, __m128i B, __m128d C) {
1284  // CHECK-LABEL: test_mm_maskstore_pd
1285  // CHECK: call void @llvm.x86.avx.maskstore.pd(i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}})
1286  _mm_maskstore_pd(A, B, C);
1287}
1288
1289void test_mm256_maskstore_pd(double* A, __m256i B, __m256d C) {
1290  // CHECK-LABEL: test_mm256_maskstore_pd
1291  // CHECK: call void @llvm.x86.avx.maskstore.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}})
1292  _mm256_maskstore_pd(A, B, C);
1293}
1294
1295void test_mm_maskstore_ps(float* A, __m128i B, __m128 C) {
1296  // CHECK-LABEL: test_mm_maskstore_ps
1297  // CHECK: call void @llvm.x86.avx.maskstore.ps(i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}})
1298  _mm_maskstore_ps(A, B, C);
1299}
1300
1301void test_mm256_maskstore_ps(float* A, __m256i B, __m256 C) {
1302  // CHECK-LABEL: test_mm256_maskstore_ps
1303  // CHECK: call void @llvm.x86.avx.maskstore.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}})
1304  _mm256_maskstore_ps(A, B, C);
1305}
1306
1307__m256d test_mm256_max_pd(__m256d A, __m256d B) {
1308  // CHECK-LABEL: test_mm256_max_pd
1309  // CHECK: call <4 x double> @llvm.x86.avx.max.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1310  return _mm256_max_pd(A, B);
1311}
1312
1313__m256 test_mm256_max_ps(__m256 A, __m256 B) {
1314  // CHECK-LABEL: test_mm256_max_ps
1315  // CHECK: call <8 x float> @llvm.x86.avx.max.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1316  return _mm256_max_ps(A, B);
1317}
1318
1319__m256d test_mm256_min_pd(__m256d A, __m256d B) {
1320  // CHECK-LABEL: test_mm256_min_pd
1321  // CHECK: call <4 x double> @llvm.x86.avx.min.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1322  return _mm256_min_pd(A, B);
1323}
1324
1325__m256 test_mm256_min_ps(__m256 A, __m256 B) {
1326  // CHECK-LABEL: test_mm256_min_ps
1327  // CHECK: call <8 x float> @llvm.x86.avx.min.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1328  return _mm256_min_ps(A, B);
1329}
1330
1331__m256d test_mm256_movedup_pd(__m256d A) {
1332  // CHECK-LABEL: test_mm256_movedup_pd
1333  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
1334  return _mm256_movedup_pd(A);
1335}
1336
1337__m256 test_mm256_movehdup_ps(__m256 A) {
1338  // CHECK-LABEL: test_mm256_movehdup_ps
1339  // 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>
1340  return _mm256_movehdup_ps(A);
1341}
1342
1343__m256 test_mm256_moveldup_ps(__m256 A) {
1344  // CHECK-LABEL: test_mm256_moveldup_ps
1345  // 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>
1346  return _mm256_moveldup_ps(A);
1347}
1348
1349int test_mm256_movemask_pd(__m256d A) {
1350  // CHECK-LABEL: test_mm256_movemask_pd
1351  // CHECK: call i32 @llvm.x86.avx.movmsk.pd.256(<4 x double> %{{.*}})
1352  return _mm256_movemask_pd(A);
1353}
1354
1355int test_mm256_movemask_ps(__m256 A) {
1356  // CHECK-LABEL: test_mm256_movemask_ps
1357  // CHECK: call i32 @llvm.x86.avx.movmsk.ps.256(<8 x float> %{{.*}})
1358  return _mm256_movemask_ps(A);
1359}
1360
1361__m256d test_mm256_mul_pd(__m256d A, __m256d B) {
1362  // CHECK-LABEL: test_mm256_mul_pd
1363  // CHECK: fmul <4 x double>
1364  return _mm256_mul_pd(A, B);
1365}
1366
1367__m256 test_mm256_mul_ps(__m256 A, __m256 B) {
1368  // CHECK-LABEL: test_mm256_mul_ps
1369  // CHECK: fmul <8 x float>
1370  return _mm256_mul_ps(A, B);
1371}
1372
1373__m256d test_mm256_or_pd(__m256d A, __m256d B) {
1374  // CHECK-LABEL: test_mm256_or_pd
1375  // CHECK: or <4 x i64>
1376  return _mm256_or_pd(A, B);
1377}
1378
1379__m256 test_mm256_or_ps(__m256 A, __m256 B) {
1380  // CHECK-LABEL: test_mm256_or_ps
1381  // CHECK: or <8 x i32>
1382  return _mm256_or_ps(A, B);
1383}
1384
1385__m128d test_mm_permute_pd(__m128d A) {
1386  // CHECK-LABEL: test_mm_permute_pd
1387  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 0>
1388  return _mm_permute_pd(A, 1);
1389}
1390
1391__m256d test_mm256_permute_pd(__m256d A) {
1392  // CHECK-LABEL: test_mm256_permute_pd
1393  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
1394  return _mm256_permute_pd(A, 5);
1395}
1396
1397__m128 test_mm_permute_ps(__m128 A) {
1398  // CHECK-LABEL: test_mm_permute_ps
1399  // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
1400  return _mm_permute_ps(A, 0x1b);
1401}
1402
1403// Test case for PR12401
1404__m128 test2_mm_permute_ps(__m128 a) {
1405  // CHECK-LABEL: test2_mm_permute_ps
1406  // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 2, i32 1, i32 2, i32 3>
1407  return _mm_permute_ps(a, 0xe6);
1408}
1409
1410__m256 test_mm256_permute_ps(__m256 A) {
1411  // CHECK-LABEL: test_mm256_permute_ps
1412  // 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>
1413  return _mm256_permute_ps(A, 0x1b);
1414}
1415
1416__m256d test_mm256_permute2f128_pd(__m256d A, __m256d B) {
1417  // CHECK-LABEL: test_mm256_permute2f128_pd
1418  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 2, i32 3, i32 6, i32 7>
1419  return _mm256_permute2f128_pd(A, B, 0x31);
1420}
1421
1422__m256 test_mm256_permute2f128_ps(__m256 A, __m256 B) {
1423  // CHECK-LABEL: test_mm256_permute2f128_ps
1424  // 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>
1425  return _mm256_permute2f128_ps(A, B, 0x13);
1426}
1427
1428__m256i test_mm256_permute2f128_si256(__m256i A, __m256i B) {
1429  // CHECK-LABEL: test_mm256_permute2f128_si256
1430  // 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>
1431  return _mm256_permute2f128_si256(A, B, 0x20);
1432}
1433
1434__m128d test_mm_permutevar_pd(__m128d A, __m128i B) {
1435  // CHECK-LABEL: test_mm_permutevar_pd
1436  // CHECK: call <2 x double> @llvm.x86.avx.vpermilvar.pd(<2 x double> %{{.*}}, <2 x i64> %{{.*}})
1437  return _mm_permutevar_pd(A, B);
1438}
1439
1440__m256d test_mm256_permutevar_pd(__m256d A, __m256i B) {
1441  // CHECK-LABEL: test_mm256_permutevar_pd
1442  // CHECK: call <4 x double> @llvm.x86.avx.vpermilvar.pd.256(<4 x double> %{{.*}}, <4 x i64> %{{.*}})
1443  return _mm256_permutevar_pd(A, B);
1444}
1445
1446__m128 test_mm_permutevar_ps(__m128 A, __m128i B) {
1447  // CHECK-LABEL: test_mm_permutevar_ps
1448  // CHECK: call <4 x float> @llvm.x86.avx.vpermilvar.ps(<4 x float> %{{.*}}, <4 x i32> %{{.*}})
1449  return _mm_permutevar_ps(A, B);
1450}
1451
1452__m256 test_mm256_permutevar_ps(__m256 A, __m256i B) {
1453  // CHECK-LABEL: test_mm256_permutevar_ps
1454  // CHECK: call <8 x float> @llvm.x86.avx.vpermilvar.ps.256(<8 x float> %{{.*}}, <8 x i32> %{{.*}})
1455  return _mm256_permutevar_ps(A, B);
1456}
1457
1458__m256 test_mm256_rcp_ps(__m256 A) {
1459  // CHECK-LABEL: test_mm256_rcp_ps
1460  // CHECK: call <8 x float> @llvm.x86.avx.rcp.ps.256(<8 x float> %{{.*}})
1461  return _mm256_rcp_ps(A);
1462}
1463
1464__m256d test_mm256_round_pd(__m256d x) {
1465  // CHECK-LABEL: test_mm256_round_pd
1466  // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 4)
1467  return _mm256_round_pd(x, 4);
1468}
1469
1470__m256 test_mm256_round_ps(__m256 x) {
1471  // CHECK-LABEL: test_mm256_round_ps
1472  // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 4)
1473  return _mm256_round_ps(x, 4);
1474}
1475
1476__m256 test_mm256_rsqrt_ps(__m256 A) {
1477  // CHECK-LABEL: test_mm256_rsqrt_ps
1478  // CHECK: call <8 x float> @llvm.x86.avx.rsqrt.ps.256(<8 x float> %{{.*}})
1479  return _mm256_rsqrt_ps(A);
1480}
1481
1482__m256i test_mm256_set_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
1483                            char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
1484                            char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
1485                            char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
1486  // CHECK-LABEL: test_mm256_set_epi8
1487  // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1488  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1489  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1490  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1491  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1492  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1493  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1494  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1495  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1496  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1497  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1498  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1499  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1500  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1501  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1502  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1503  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1504  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1505  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1506  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1507  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1508  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1509  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1510  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1511  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1512  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1513  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1514  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1515  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1516  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1517  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1518  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1519  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);
1520}
1521
1522__m256i test_mm256_set_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
1523                             short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
1524  // CHECK-LABEL: test_mm256_set_epi16
1525  // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1526  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1527  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1528  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1529  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1530  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1531  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1532  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1533  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1534  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1535  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1536  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1537  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1538  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1539  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1540  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1541  return _mm256_set_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
1542}
1543
1544__m256i test_mm256_set_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
1545  // CHECK-LABEL: test_mm256_set_epi32
1546  // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1547  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1548  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1549  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1550  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1551  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1552  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1553  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1554  return _mm256_set_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
1555}
1556
1557__m256i test_mm256_set_epi64x(long long A0, long long A1, long long A2, long long A3) {
1558  // CHECK-LABEL: test_mm256_set_epi64x
1559  // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1560  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1561  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1562  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1563  return _mm256_set_epi64x(A0, A1, A2, A3);
1564}
1565
1566__m256 test_mm256_set_m128(__m128 A, __m128 B) {
1567  // CHECK-LABEL: test_mm256_set_m128
1568  // 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>
1569  return _mm256_set_m128(A, B);
1570}
1571
1572__m256d test_mm256_set_m128d(__m128d A, __m128d B) {
1573  // CHECK-LABEL: test_mm256_set_m128d
1574  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1575  return _mm256_set_m128d(A, B);
1576}
1577
1578__m256i test_mm256_set_m128i(__m128i A, __m128i B) {
1579  // CHECK-LABEL: test_mm256_set_m128i
1580  // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1581  return _mm256_set_m128i(A, B);
1582}
1583
1584__m256d test_mm256_set_pd(double A0, double A1, double A2, double A3) {
1585  // CHECK-LABEL: test_mm256_set_pd
1586  // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1587  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1588  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1589  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1590  return _mm256_set_pd(A0, A1, A2, A3);
1591}
1592
1593__m256 test_mm256_set_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
1594  // CHECK-LABEL: test_mm256_set_ps
1595  // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1596  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1597  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1598  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1599  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1600  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1601  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1602  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1603  return _mm256_set_ps(A0, A1, A2, A3, A4, A5, A6, A7);
1604}
1605
1606__m256i test_mm256_set1_epi8(char A) {
1607  // CHECK-LABEL: test_mm256_set1_epi8
1608  // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1609  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1610  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1611  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1612  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1613  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1614  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1615  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1616  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1617  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1618  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1619  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1620  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1621  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1622  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1623  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1624  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1625  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1626  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1627  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1628  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1629  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1630  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1631  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1632  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1633  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1634  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1635  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1636  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1637  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1638  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1639  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1640  return _mm256_set1_epi8(A);
1641}
1642
1643__m256i test_mm256_set1_epi16(short A) {
1644  // CHECK-LABEL: test_mm256_set1_epi16
1645  // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1646  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1647  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1648  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1649  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1650  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1651  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1652  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1653  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1654  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1655  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1656  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1657  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1658  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1659  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1660  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1661  return _mm256_set1_epi16(A);
1662}
1663
1664__m256i test_mm256_set1_epi32(int A) {
1665  // CHECK-LABEL: test_mm256_set1_epi32
1666  // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1667  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1668  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1669  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1670  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1671  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1672  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1673  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1674  return _mm256_set1_epi32(A);
1675}
1676
1677__m256i test_mm256_set1_epi64x(long long A) {
1678  // CHECK-LABEL: test_mm256_set1_epi64x
1679  // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1680  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1681  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1682  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1683  return _mm256_set1_epi64x(A);
1684}
1685
1686__m256d test_mm256_set1_pd(double A) {
1687  // CHECK-LABEL: test_mm256_set1_pd
1688  // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1689  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1690  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1691  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1692  return _mm256_set1_pd(A);
1693}
1694
1695__m256 test_mm256_set1_ps(float A) {
1696  // CHECK-LABEL: test_mm256_set1_ps
1697  // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1698  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1699  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1700  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1701  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1702  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1703  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1704  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1705  return _mm256_set1_ps(A);
1706}
1707
1708__m256i test_mm256_setr_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7,
1709                             char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15,
1710                             char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23,
1711                             char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) {
1712  // CHECK-LABEL: test_mm256_setr_epi8
1713  // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0
1714  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1715  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1716  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1717  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1718  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1719  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1720  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1721  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1722  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1723  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1724  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1725  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1726  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1727  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1728  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1729  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1730  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1731  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1732  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1733  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1734  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1735  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1736  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1737  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1738  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1739  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1740  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1741  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1742  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1743  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1744  // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1745  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);
1746}
1747
1748__m256i test_mm256_setr_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7,
1749                              short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) {
1750  // CHECK-LABEL: test_mm256_setr_epi16
1751  // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0
1752  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1
1753  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2
1754  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3
1755  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4
1756  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5
1757  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6
1758  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7
1759  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8
1760  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9
1761  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10
1762  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11
1763  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12
1764  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13
1765  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14
1766  // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15
1767  return _mm256_setr_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
1768}
1769
1770__m256i test_mm256_setr_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) {
1771  // CHECK-LABEL: test_mm256_setr_epi32
1772  // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0
1773  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1
1774  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2
1775  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3
1776  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4
1777  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5
1778  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6
1779  // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7
1780  return _mm256_setr_epi32(A0, A1, A2, A3, A4, A5, A6, A7);
1781}
1782
1783__m256i test_mm256_setr_epi64x(long long A0, long long A1, long long A2, long long A3) {
1784  // CHECK-LABEL: test_mm256_setr_epi64x
1785  // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0
1786  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1
1787  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2
1788  // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3
1789  return _mm256_setr_epi64x(A0, A1, A2, A3);
1790}
1791
1792__m256 test_mm256_setr_m128(__m128 A, __m128 B) {
1793  // CHECK-LABEL: test_mm256_setr_m128
1794  // 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>
1795  return _mm256_setr_m128(A, B);
1796}
1797
1798__m256d test_mm256_setr_m128d(__m128d A, __m128d B) {
1799  // CHECK-LABEL: test_mm256_setr_m128d
1800  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1801  return _mm256_setr_m128d(A, B);
1802}
1803
1804__m256i test_mm256_setr_m128i(__m128i A, __m128i B) {
1805  // CHECK-LABEL: test_mm256_setr_m128i
1806  // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1807  return _mm256_setr_m128i(A, B);
1808}
1809
1810__m256d test_mm256_setr_pd(double A0, double A1, double A2, double A3) {
1811  // CHECK-LABEL: test_mm256_setr_pd
1812  // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0
1813  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1
1814  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2
1815  // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3
1816  return _mm256_setr_pd(A0, A1, A2, A3);
1817}
1818
1819__m256 test_mm256_setr_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) {
1820  // CHECK-LABEL: test_mm256_setr_ps
1821  // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0
1822  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1
1823  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2
1824  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3
1825  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4
1826  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5
1827  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6
1828  // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7
1829  return _mm256_setr_ps(A0, A1, A2, A3, A4, A5, A6, A7);
1830}
1831
1832__m256d test_mm256_setzero_pd() {
1833  // CHECK-LABEL: test_mm256_setzero_pd
1834  // CHECK: store <4 x double> zeroinitializer
1835  return _mm256_setzero_pd();
1836}
1837
1838__m256 test_mm256_setzero_ps() {
1839  // CHECK-LABEL: test_mm256_setzero_ps
1840  // CHECK: store <8 x float> zeroinitializer
1841  return _mm256_setzero_ps();
1842}
1843
1844__m256i test_mm256_setzero_si256() {
1845  // CHECK-LABEL: test_mm256_setzero_si256
1846  // CHECK: store <4 x i64> zeroinitializer
1847  return _mm256_setzero_si256();
1848}
1849
1850__m256d test_mm256_shuffle_pd(__m256d A, __m256d B) {
1851  // CHECK-LABEL: test_mm256_shuffle_pd
1852  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1853  return _mm256_shuffle_pd(A, B, 0);
1854}
1855
1856__m256 test_mm256_shuffle_ps(__m256 A, __m256 B) {
1857  // CHECK-LABEL: test_mm256_shuffle_ps
1858  // 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>
1859  return _mm256_shuffle_ps(A, B, 0);
1860}
1861
1862__m256d test_mm256_sqrt_pd(__m256d A) {
1863  // CHECK-LABEL: test_mm256_sqrt_pd
1864  // CHECK: call <4 x double> @llvm.sqrt.v4f64(<4 x double> %{{.*}})
1865  return _mm256_sqrt_pd(A);
1866}
1867
1868__m256 test_mm256_sqrt_ps(__m256 A) {
1869  // CHECK-LABEL: test_mm256_sqrt_ps
1870  // CHECK: call <8 x float> @llvm.sqrt.v8f32(<8 x float> %{{.*}})
1871  return _mm256_sqrt_ps(A);
1872}
1873
1874void test_mm256_store_pd(double* A, __m256d B) {
1875  // CHECK-LABEL: test_mm256_store_pd
1876  // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32
1877  _mm256_store_pd(A, B);
1878}
1879
1880void test_mm256_store_ps(float* A, __m256 B) {
1881  // CHECK-LABEL: test_mm256_store_ps
1882  // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32
1883  _mm256_store_ps(A, B);
1884}
1885
1886void test_mm256_store_si256(__m256i* A, __m256i B) {
1887  // CHECK-LABEL: test_mm256_store_si256
1888  // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32
1889  _mm256_store_si256(A, B);
1890}
1891
1892void test_mm256_storeu_pd(double* A, __m256d B) {
1893  // CHECK-LABEL: test_mm256_storeu_pd
1894  // CHECK:   store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 1{{$}}
1895  // CHECK-NEXT: ret void
1896  _mm256_storeu_pd(A, B);
1897}
1898
1899void test_mm256_storeu_ps(float* A, __m256 B) {
1900  // CHECK-LABEL: test_mm256_storeu_ps
1901  // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 1{{$}}
1902  // CHECk-NEXT: ret void
1903  _mm256_storeu_ps(A, B);
1904}
1905
1906void test_mm256_storeu_si256(__m256i* A, __m256i B) {
1907  // CHECK-LABEL: test_mm256_storeu_si256
1908  // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 1{{$}}
1909  // CHECk-NEXT: ret void
1910  _mm256_storeu_si256(A, B);
1911}
1912
1913void test_mm256_storeu2_m128(float* A, float* B, __m256 C) {
1914  // CHECK-LABEL: test_mm256_storeu2_m128
1915  // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1916  // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}}
1917  // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1918  // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}}
1919  _mm256_storeu2_m128(A, B, C);
1920}
1921
1922void test_mm256_storeu2_m128d(double* A, double* B, __m256d C) {
1923  // CHECK-LABEL: test_mm256_storeu2_m128d
1924  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1>
1925  // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}}
1926  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3>
1927  // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}}
1928  _mm256_storeu2_m128d(A, B, C);
1929}
1930
1931void test_mm256_storeu2_m128i(__m128i* A, __m128i* B, __m256i C) {
1932  // CHECK-LABEL: test_mm256_storeu2_m128i
1933  // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1>
1934  // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
1935  // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1936  // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}}
1937  _mm256_storeu2_m128i(A, B, C);
1938}
1939
1940void test_mm256_stream_pd(double* A, __m256d B) {
1941  // CHECK-LABEL: test_mm256_stream_pd
1942  // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32, !nontemporal
1943  _mm256_stream_pd(A, B);
1944}
1945
1946void test_mm256_stream_ps(float* A, __m256 B) {
1947  // CHECK-LABEL: test_mm256_stream_ps
1948  // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32, !nontemporal
1949  _mm256_stream_ps(A, B);
1950}
1951
1952void test_mm256_stream_si256(__m256i* A, __m256i B) {
1953  // CHECK-LABEL: test_mm256_stream_si256
1954  // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32, !nontemporal
1955  _mm256_stream_si256(A, B);
1956}
1957
1958__m256d test_mm256_sub_pd(__m256d A, __m256d B) {
1959  // CHECK-LABEL: test_mm256_sub_pd
1960  // CHECK: fsub <4 x double>
1961  return _mm256_sub_pd(A, B);
1962}
1963
1964__m256 test_mm256_sub_ps(__m256 A, __m256 B) {
1965  // CHECK-LABEL: test_mm256_sub_ps
1966  // CHECK: fsub <8 x float>
1967  return _mm256_sub_ps(A, B);
1968}
1969
1970int test_mm_testc_pd(__m128d A, __m128d B) {
1971  // CHECK-LABEL: test_mm_testc_pd
1972  // CHECK: call i32 @llvm.x86.avx.vtestc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
1973  return _mm_testc_pd(A, B);
1974}
1975
1976int test_mm256_testc_pd(__m256d A, __m256d B) {
1977  // CHECK-LABEL: test_mm256_testc_pd
1978  // CHECK: call i32 @llvm.x86.avx.vtestc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
1979  return _mm256_testc_pd(A, B);
1980}
1981
1982int test_mm_testc_ps(__m128 A, __m128 B) {
1983  // CHECK-LABEL: test_mm_testc_ps
1984  // CHECK: call i32 @llvm.x86.avx.vtestc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
1985  return _mm_testc_ps(A, B);
1986}
1987
1988int test_mm256_testc_ps(__m256 A, __m256 B) {
1989  // CHECK-LABEL: test_mm256_testc_ps
1990  // CHECK: call i32 @llvm.x86.avx.vtestc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
1991  return _mm256_testc_ps(A, B);
1992}
1993
1994int test_mm256_testc_si256(__m256i A, __m256i B) {
1995  // CHECK-LABEL: test_mm256_testc_si256
1996  // CHECK: call i32 @llvm.x86.avx.ptestc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
1997  return _mm256_testc_si256(A, B);
1998}
1999
2000int test_mm_testnzc_pd(__m128d A, __m128d B) {
2001  // CHECK-LABEL: test_mm_testnzc_pd
2002  // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2003  return _mm_testnzc_pd(A, B);
2004}
2005
2006int test_mm256_testnzc_pd(__m256d A, __m256d B) {
2007  // CHECK-LABEL: test_mm256_testnzc_pd
2008  // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
2009  return _mm256_testnzc_pd(A, B);
2010}
2011
2012int test_mm_testnzc_ps(__m128 A, __m128 B) {
2013  // CHECK-LABEL: test_mm_testnzc_ps
2014  // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
2015  return _mm_testnzc_ps(A, B);
2016}
2017
2018int test_mm256_testnzc_ps(__m256 A, __m256 B) {
2019  // CHECK-LABEL: test_mm256_testnzc_ps
2020  // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
2021  return _mm256_testnzc_ps(A, B);
2022}
2023
2024int test_mm256_testnzc_si256(__m256i A, __m256i B) {
2025  // CHECK-LABEL: test_mm256_testnzc_si256
2026  // CHECK: call i32 @llvm.x86.avx.ptestnzc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2027  return _mm256_testnzc_si256(A, B);
2028}
2029
2030int test_mm_testz_pd(__m128d A, __m128d B) {
2031  // CHECK-LABEL: test_mm_testz_pd
2032  // CHECK: call i32 @llvm.x86.avx.vtestz.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}})
2033  return _mm_testz_pd(A, B);
2034}
2035
2036int test_mm256_testz_pd(__m256d A, __m256d B) {
2037  // CHECK-LABEL: test_mm256_testz_pd
2038  // CHECK: call i32 @llvm.x86.avx.vtestz.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}})
2039  return _mm256_testz_pd(A, B);
2040}
2041
2042int test_mm_testz_ps(__m128 A, __m128 B) {
2043  // CHECK-LABEL: test_mm_testz_ps
2044  // CHECK: call i32 @llvm.x86.avx.vtestz.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}})
2045  return _mm_testz_ps(A, B);
2046}
2047
2048int test_mm256_testz_ps(__m256 A, __m256 B) {
2049  // CHECK-LABEL: test_mm256_testz_ps
2050  // CHECK: call i32 @llvm.x86.avx.vtestz.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}})
2051  return _mm256_testz_ps(A, B);
2052}
2053
2054int test_mm256_testz_si256(__m256i A, __m256i B) {
2055  // CHECK-LABEL: test_mm256_testz_si256
2056  // CHECK: call i32 @llvm.x86.avx.ptestz.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
2057  return _mm256_testz_si256(A, B);
2058}
2059
2060__m256 test_mm256_undefined_ps() {
2061  // CHECK-LABEL: @test_mm256_undefined_ps
2062  // CHECK: ret <8 x float> zeroinitializer
2063  return _mm256_undefined_ps();
2064}
2065
2066__m256d test_mm256_undefined_pd() {
2067  // CHECK-LABEL: @test_mm256_undefined_pd
2068  // CHECK: ret <4 x double> zeroinitializer
2069  return _mm256_undefined_pd();
2070}
2071
2072__m256i test_mm256_undefined_si256() {
2073  // CHECK-LABEL: @test_mm256_undefined_si256
2074  // CHECK: ret <4 x i64> zeroinitializer
2075  return _mm256_undefined_si256();
2076}
2077
2078__m256d test_mm256_unpackhi_pd(__m256d A, __m256d B) {
2079  // CHECK-LABEL: test_mm256_unpackhi_pd
2080  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
2081  return _mm256_unpackhi_pd(A, B);
2082}
2083
2084__m256 test_mm256_unpackhi_ps(__m256 A, __m256 B) {
2085  // CHECK-LABEL: test_mm256_unpackhi_ps
2086  // 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>
2087  return _mm256_unpackhi_ps(A, B);
2088}
2089
2090__m256d test_mm256_unpacklo_pd(__m256d A, __m256d B) {
2091  // CHECK-LABEL: test_mm256_unpacklo_pd
2092  // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
2093  return _mm256_unpacklo_pd(A, B);
2094}
2095
2096__m256 test_mm256_unpacklo_ps(__m256 A, __m256 B) {
2097  // CHECK-LABEL: test_mm256_unpacklo_ps
2098  // 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>
2099  return _mm256_unpacklo_ps(A, B);
2100}
2101
2102__m256d test_mm256_xor_pd(__m256d A, __m256d B) {
2103  // CHECK-LABEL: test_mm256_xor_pd
2104  // CHECK: xor <4 x i64>
2105  return _mm256_xor_pd(A, B);
2106}
2107
2108__m256 test_mm256_xor_ps(__m256 A, __m256 B) {
2109  // CHECK-LABEL: test_mm256_xor_ps
2110  // CHECK: xor <8 x i32>
2111  return _mm256_xor_ps(A, B);
2112}
2113
2114void test_mm256_zeroall() {
2115  // CHECK-LABEL: test_mm256_zeroall
2116  // CHECK: call void @llvm.x86.avx.vzeroall()
2117  return _mm256_zeroall();
2118}
2119
2120void test_mm256_zeroupper() {
2121  // CHECK-LABEL: test_mm256_zeroupper
2122  // CHECK: call void @llvm.x86.avx.vzeroupper()
2123  return _mm256_zeroupper();
2124}
2125
2126__m256d test_mm256_zextpd128_pd256(__m128d A) {
2127  // CHECK-LABEL: test_mm256_zextpd128_pd256
2128  // CHECK: store <2 x double> zeroinitializer
2129  // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2130  return _mm256_zextpd128_pd256(A);
2131}
2132
2133__m256 test_mm256_zextps128_ps256(__m128 A) {
2134  // CHECK-LABEL: test_mm256_zextps128_ps256
2135  // CHECK: store <4 x float> zeroinitializer
2136  // 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>
2137  return _mm256_zextps128_ps256(A);
2138}
2139
2140__m256i test_mm256_zextsi128_si256(__m128i A) {
2141  // CHECK-LABEL: test_mm256_zextsi128_si256
2142  // CHECK: store <2 x i64> zeroinitializer
2143  // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2144  return _mm256_zextsi128_si256(A);
2145}
2146
2147double test_mm256_cvtsd_f64(__m256d __a)
2148{
2149  // CHECK-LABEL: @test_mm256_cvtsd_f64
2150  // CHECK: extractelement <4 x double> %{{.*}}, i32 0
2151  return _mm256_cvtsd_f64(__a);
2152}
2153
2154int test_mm256_cvtsi256_si32(__m256i __a)
2155{
2156  // CHECK-LABEL: @test_mm256_cvtsi256_si32
2157  // CHECK: extractelement <8 x i32> %{{.*}}, i32 0
2158  return _mm256_cvtsi256_si32(__a);
2159}
2160
2161float test_mm256_cvtss_f32(__m256 __a)
2162{
2163  // CHECK-LABEL: @test_mm256_cvtss_f32
2164  // CHECK: extractelement <8 x float> %{{.*}}, i32 0
2165  return _mm256_cvtss_f32(__a);
2166}
2167
CodeThinker, Enjoy your reading code