?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "[llvm] Improve llvm.objectsize computation by computing GEP, alloca and mallo...
[llvm-project.git] / clang / test / CodeGen / X86 / avx512vlfp16-builtins.c
blob3a212ed6834371d605e036147f18eba3b4738c9c
1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-unknown-unknown -target-feature +avx512vl -target-feature +avx512fp16 -emit-llvm -o - -Wall -Werror | FileCheck %s
2
3 #include <immintrin.h>
4
5 _Float16 test_mm_cvtsh_h(__m128h __A) {
6 // CHECK-LABEL: @test_mm_cvtsh_h
7 // CHECK: extractelement <8 x half> %{{.*}}, i32 0
8 return _mm_cvtsh_h(__A);
9 }
10
11 _Float16 test_mm256_cvtsh_h(__m256h __A) {
12 // CHECK-LABEL: @test_mm256_cvtsh_h
13 // CHECK: extractelement <16 x half> %{{.*}}, i32 0
14 return _mm256_cvtsh_h(__A);
15 }
16
17 __m128h test_mm_set_sh(_Float16 __h) {
18 // CHECK-LABEL: @test_mm_set_sh
19 // CHECK: insertelement <8 x half> {{.*}}, i32 0
20 // CHECK: insertelement <8 x half> %{{.*}}, half 0xH0000, i32 1
21 // CHECK: insertelement <8 x half> %{{.*}}, half 0xH0000, i32 2
22 // CHECK: insertelement <8 x half> %{{.*}}, half 0xH0000, i32 3
23 // CHECK: insertelement <8 x half> %{{.*}}, half 0xH0000, i32 4
24 // CHECK: insertelement <8 x half> %{{.*}}, half 0xH0000, i32 5
25 // CHECK: insertelement <8 x half> %{{.*}}, half 0xH0000, i32 6
26 // CHECK: insertelement <8 x half> %{{.*}}, half 0xH0000, i32 7
27 return _mm_set_sh(__h);
28 }
29
30 __m128h test_mm_set1_ph(_Float16 h) {
31 // CHECK-LABEL: @test_mm_set1_ph
32 // CHECK: insertelement <8 x half> {{.*}}, i32 0
33 // CHECK: insertelement <8 x half> {{.*}}, i32 1
34 // CHECK: insertelement <8 x half> {{.*}}, i32 2
35 // CHECK: insertelement <8 x half> {{.*}}, i32 3
36 // CHECK: insertelement <8 x half> {{.*}}, i32 4
37 // CHECK: insertelement <8 x half> {{.*}}, i32 5
38 // CHECK: insertelement <8 x half> {{.*}}, i32 6
39 // CHECK: insertelement <8 x half> {{.*}}, i32 7
40 return _mm_set1_ph(h);
41 }
42
43 __m256h test_mm256_set1_ph(_Float16 h) {
44 // CHECK-LABEL: @test_mm256_set1_ph
45 // CHECK: insertelement <16 x half> {{.*}}, i32 0
46 // CHECK: insertelement <16 x half> {{.*}}, i32 1
47 // CHECK: insertelement <16 x half> {{.*}}, i32 2
48 // CHECK: insertelement <16 x half> {{.*}}, i32 3
49 // CHECK: insertelement <16 x half> {{.*}}, i32 4
50 // CHECK: insertelement <16 x half> {{.*}}, i32 5
51 // CHECK: insertelement <16 x half> {{.*}}, i32 6
52 // CHECK: insertelement <16 x half> {{.*}}, i32 7
53 // CHECK: insertelement <16 x half> {{.*}}, i32 8
54 // CHECK: insertelement <16 x half> {{.*}}, i32 9
55 // CHECK: insertelement <16 x half> {{.*}}, i32 10
56 // CHECK: insertelement <16 x half> {{.*}}, i32 11
57 // CHECK: insertelement <16 x half> {{.*}}, i32 12
58 // CHECK: insertelement <16 x half> {{.*}}, i32 13
59 // CHECK: insertelement <16 x half> {{.*}}, i32 14
60 // CHECK: insertelement <16 x half> {{.*}}, i32 15
61 return _mm256_set1_ph(h);
62 }
63
64 __m128h test_mm_set1_pch(_Float16 _Complex h) {
65 // CHECK-LABEL: @test_mm_set1_pch
66 // CHECK: insertelement <4 x float> {{.*}}, i32 0
67 // CHECK: insertelement <4 x float> {{.*}}, i32 1
68 // CHECK: insertelement <4 x float> {{.*}}, i32 2
69 // CHECK: insertelement <4 x float> {{.*}}, i32 3
70 return _mm_set1_pch(h);
71 }
72
73 __m256h test_mm256_set1_pch(_Float16 _Complex h) {
74 // CHECK-LABEL: @test_mm256_set1_pch
75 // CHECK: insertelement <8 x float> {{.*}}, i32 0
76 // CHECK: insertelement <8 x float> {{.*}}, i32 1
77 // CHECK: insertelement <8 x float> {{.*}}, i32 2
78 // CHECK: insertelement <8 x float> {{.*}}, i32 3
79 // CHECK: insertelement <8 x float> {{.*}}, i32 4
80 // CHECK: insertelement <8 x float> {{.*}}, i32 5
81 // CHECK: insertelement <8 x float> {{.*}}, i32 6
82 // CHECK: insertelement <8 x float> {{.*}}, i32 7
83 return _mm256_set1_pch(h);
84 }
85
86 __m128h test_mm_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
87 _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8) {
88 // CHECK-LABEL: @test_mm_set_ph
89 // CHECK: insertelement <8 x half> {{.*}}, i32 0
90 // CHECK: insertelement <8 x half> {{.*}}, i32 1
91 // CHECK: insertelement <8 x half> {{.*}}, i32 2
92 // CHECK: insertelement <8 x half> {{.*}}, i32 3
93 // CHECK: insertelement <8 x half> {{.*}}, i32 4
94 // CHECK: insertelement <8 x half> {{.*}}, i32 5
95 // CHECK: insertelement <8 x half> {{.*}}, i32 6
96 // CHECK: insertelement <8 x half> {{.*}}, i32 7
97 return _mm_set_ph(__h1, __h2, __h3, __h4, __h5, __h6, __h7, __h8);
98 }
99
100 __m256h test_mm256_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
101 _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8,
102 _Float16 __h9, _Float16 __h10, _Float16 __h11, _Float16 __h12,
103 _Float16 __h13, _Float16 __h14, _Float16 __h15, _Float16 __h16) {
104 // CHECK-LABEL: @test_mm256_set_ph
105 // CHECK: insertelement <16 x half> {{.*}}, i32 0
106 // CHECK: insertelement <16 x half> {{.*}}, i32 1
107 // CHECK: insertelement <16 x half> {{.*}}, i32 2
108 // CHECK: insertelement <16 x half> {{.*}}, i32 3
109 // CHECK: insertelement <16 x half> {{.*}}, i32 4
110 // CHECK: insertelement <16 x half> {{.*}}, i32 5
111 // CHECK: insertelement <16 x half> {{.*}}, i32 6
112 // CHECK: insertelement <16 x half> {{.*}}, i32 7
113 // CHECK: insertelement <16 x half> {{.*}}, i32 8
114 // CHECK: insertelement <16 x half> {{.*}}, i32 9
115 // CHECK: insertelement <16 x half> {{.*}}, i32 10
116 // CHECK: insertelement <16 x half> {{.*}}, i32 11
117 // CHECK: insertelement <16 x half> {{.*}}, i32 12
118 // CHECK: insertelement <16 x half> {{.*}}, i32 13
119 // CHECK: insertelement <16 x half> {{.*}}, i32 14
120 // CHECK: insertelement <16 x half> {{.*}}, i32 15
121 return _mm256_set_ph(__h1, __h2, __h3, __h4, __h5, __h6, __h7, __h8,
122 __h9, __h10, __h11, __h12, __h13, __h14, __h15, __h16);
123 }
124
125 __m128h test_mm_setr_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
126 _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8) {
127 // CHECK-LABEL: @test_mm_setr_ph
128 // CHECK: insertelement <8 x half> {{.*}}, i32 0
129 // CHECK: insertelement <8 x half> {{.*}}, i32 1
130 // CHECK: insertelement <8 x half> {{.*}}, i32 2
131 // CHECK: insertelement <8 x half> {{.*}}, i32 3
132 // CHECK: insertelement <8 x half> {{.*}}, i32 4
133 // CHECK: insertelement <8 x half> {{.*}}, i32 5
134 // CHECK: insertelement <8 x half> {{.*}}, i32 6
135 // CHECK: insertelement <8 x half> {{.*}}, i32 7
136 return _mm_setr_ph(__h1, __h2, __h3, __h4, __h5, __h6, __h7, __h8);
137 }
138
139 __m256h test_mm256_setr_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
140 _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8,
141 _Float16 __h9, _Float16 __h10, _Float16 __h11, _Float16 __h12,
142 _Float16 __h13, _Float16 __h14, _Float16 __h15, _Float16 __h16) {
143 // CHECK-LABEL: @test_mm256_setr_ph
144 // CHECK: insertelement <16 x half> {{.*}}, i32 0
145 // CHECK: insertelement <16 x half> {{.*}}, i32 1
146 // CHECK: insertelement <16 x half> {{.*}}, i32 2
147 // CHECK: insertelement <16 x half> {{.*}}, i32 3
148 // CHECK: insertelement <16 x half> {{.*}}, i32 4
149 // CHECK: insertelement <16 x half> {{.*}}, i32 5
150 // CHECK: insertelement <16 x half> {{.*}}, i32 6
151 // CHECK: insertelement <16 x half> {{.*}}, i32 7
152 // CHECK: insertelement <16 x half> {{.*}}, i32 8
153 // CHECK: insertelement <16 x half> {{.*}}, i32 9
154 // CHECK: insertelement <16 x half> {{.*}}, i32 10
155 // CHECK: insertelement <16 x half> {{.*}}, i32 11
156 // CHECK: insertelement <16 x half> {{.*}}, i32 12
157 // CHECK: insertelement <16 x half> {{.*}}, i32 13
158 // CHECK: insertelement <16 x half> {{.*}}, i32 14
159 // CHECK: insertelement <16 x half> {{.*}}, i32 15
160 return _mm256_setr_ph(__h1, __h2, __h3, __h4, __h5, __h6, __h7, __h8,
161 __h9, __h10, __h11, __h12, __h13, __h14, __h15, __h16);
162 }
163
164 __m256h test_mm256_add_ph(__m256h __A, __m256h __B) {
165 // CHECK-LABEL: @test_mm256_add_ph
166 // CHECK: %{{.*}} = fadd <16 x half> %{{.*}}, %{{.*}}
167 return _mm256_add_ph(__A, __B);
168 }
169
170 __m256h test_mm256_mask_add_ph(__m256h __W, __mmask32 __U, __m256h __A, __m256h __B) {
171 // CHECK-LABEL: @test_mm256_mask_add_ph
172 // CHECK: %{{.*}} = fadd <16 x half> %{{.*}}, %{{.*}}
173 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
174 return (__m256h)_mm256_mask_add_ph(__W, __U, __A, __B);
175 }
176
177 __m256h test_mm256_maskz_add_ph(__mmask32 __U, __m256h __A, __m256h __B) {
178 // CHECK-LABEL: @test_mm256_maskz_add_ph
179 // CHECK: %{{.*}} = fadd <16 x half> %{{.*}}, %{{.*}}
180 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
181 return _mm256_maskz_add_ph(__U, __A, __B);
182 }
183
184 __m128h test_mm_add_ph(__m128h __A, __m128h __B) {
185 // CHECK-LABEL: @test_mm_add_ph
186 // CHECK: %{{.*}} = fadd <8 x half> %{{.*}}, %{{.*}}
187 return _mm_add_ph(__A, __B);
188 }
189
190 __m128h test_mm_mask_add_ph(__m128h __W, __mmask32 __U, __m128h __A, __m128h __B) {
191 // CHECK-LABEL: @test_mm_mask_add_ph
192 // CHECK: %{{.*}} = fadd <8 x half> %{{.*}}, %{{.*}}
193 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
194 return (__m128h)_mm_mask_add_ph(__W, __U, __A, __B);
195 }
196
197 __m128h test_mm_maskz_add_ph(__mmask32 __U, __m128h __A, __m128h __B) {
198 // CHECK-LABEL: @test_mm_maskz_add_ph
199 // CHECK: %{{.*}} = fadd <8 x half> %{{.*}}, %{{.*}}
200 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
201 return _mm_maskz_add_ph(__U, __A, __B);
202 }
203
204 __m256h test_mm256_sub_ph(__m256h __A, __m256h __B) {
205 // CHECK-LABEL: @test_mm256_sub_ph
206 // CHECK: %{{.*}} = fsub <16 x half> %{{.*}}, %{{.*}}
207 return _mm256_sub_ph(__A, __B);
208 }
209
210 __m256h test_mm256_mask_sub_ph(__m256h __W, __mmask32 __U, __m256h __A, __m256h __B) {
211 // CHECK-LABEL: @test_mm256_mask_sub_ph
212 // CHECK: %{{.*}} = fsub <16 x half> %{{.*}}, %{{.*}}
213 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
214 return (__m256h)_mm256_mask_sub_ph(__W, __U, __A, __B);
215 }
216
217 __m256h test_mm256_maskz_sub_ph(__mmask32 __U, __m256h __A, __m256h __B) {
218 // CHECK-LABEL: @test_mm256_maskz_sub_ph
219 // CHECK: %{{.*}} = fsub <16 x half> %{{.*}}, %{{.*}}
220 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
221 return _mm256_maskz_sub_ph(__U, __A, __B);
222 }
223
224 __m128h test_mm_sub_ph(__m128h __A, __m128h __B) {
225 // CHECK-LABEL: @test_mm_sub_ph
226 // CHECK: %{{.*}} = fsub <8 x half> %{{.*}}, %{{.*}}
227 return _mm_sub_ph(__A, __B);
228 }
229
230 __m128h test_mm_mask_sub_ph(__m128h __W, __mmask32 __U, __m128h __A, __m128h __B) {
231 // CHECK-LABEL: @test_mm_mask_sub_ph
232 // CHECK: %{{.*}} = fsub <8 x half> %{{.*}}, %{{.*}}
233 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
234 return (__m128h)_mm_mask_sub_ph(__W, __U, __A, __B);
235 }
236
237 __m128h test_mm_maskz_sub_ph(__mmask32 __U, __m128h __A, __m128h __B) {
238 // CHECK-LABEL: @test_mm_maskz_sub_ph
239 // CHECK: %{{.*}} = fsub <8 x half> %{{.*}}, %{{.*}}
240 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
241 return _mm_maskz_sub_ph(__U, __A, __B);
242 }
243
244 __m256h test_mm256_mul_ph(__m256h __A, __m256h __B) {
245 // CHECK-LABEL: @test_mm256_mul_ph
246 // CHECK: %{{.*}} = fmul <16 x half> %{{.*}}, %{{.*}}
247 return _mm256_mul_ph(__A, __B);
248 }
249
250 __m256h test_mm256_mask_mul_ph(__m256h __W, __mmask32 __U, __m256h __A, __m256h __B) {
251 // CHECK-LABEL: @test_mm256_mask_mul_ph
252 // CHECK: %{{.*}} = fmul <16 x half> %{{.*}}, %{{.*}}
253 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
254 return (__m256h)_mm256_mask_mul_ph(__W, __U, __A, __B);
255 }
256
257 __m256h test_mm256_maskz_mul_ph(__mmask32 __U, __m256h __A, __m256h __B) {
258 // CHECK-LABEL: @test_mm256_maskz_mul_ph
259 // CHECK: %{{.*}} = fmul <16 x half> %{{.*}}, %{{.*}}
260 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
261 return _mm256_maskz_mul_ph(__U, __A, __B);
262 }
263
264 __m128h test_mm_mul_ph(__m128h __A, __m128h __B) {
265 // CHECK-LABEL: @test_mm_mul_ph
266 // CHECK: %{{.*}} = fmul <8 x half> %{{.*}}, %{{.*}}
267 return _mm_mul_ph(__A, __B);
268 }
269
270 __m128h test_mm_mask_mul_ph(__m128h __W, __mmask32 __U, __m128h __A, __m128h __B) {
271 // CHECK-LABEL: @test_mm_mask_mul_ph
272 // CHECK: %{{.*}} = fmul <8 x half> %{{.*}}, %{{.*}}
273 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
274 return (__m128h)_mm_mask_mul_ph(__W, __U, __A, __B);
275 }
276
277 __m128h test_mm_maskz_mul_ph(__mmask32 __U, __m128h __A, __m128h __B) {
278 // CHECK-LABEL: @test_mm_maskz_mul_ph
279 // CHECK: %{{.*}} = fmul <8 x half> %{{.*}}, %{{.*}}
280 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
281 return _mm_maskz_mul_ph(__U, __A, __B);
282 }
283
284 __m256h test_mm256_div_ph(__m256h __A, __m256h __B) {
285 // CHECK-LABEL: @test_mm256_div_ph
286 // CHECK: %{{.*}} = fdiv <16 x half> %{{.*}}, %{{.*}}
287 return _mm256_div_ph(__A, __B);
288 }
289
290 __m256h test_mm256_mask_div_ph(__m256h __W, __mmask32 __U, __m256h __A, __m256h __B) {
291 // CHECK-LABEL: @test_mm256_mask_div_ph
292 // CHECK: %{{.*}} = fdiv <16 x half> %{{.*}}, %{{.*}}
293 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
294 return (__m256h)_mm256_mask_div_ph(__W, __U, __A, __B);
295 }
296
297 __m256h test_mm256_maskz_div_ph(__mmask32 __U, __m256h __A, __m256h __B) {
298 // CHECK-LABEL: @test_mm256_maskz_div_ph
299 // CHECK: %{{.*}} = fdiv <16 x half> %{{.*}}, %{{.*}}
300 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
301 return _mm256_maskz_div_ph(__U, __A, __B);
302 }
303
304 __m128h test_mm_div_ph(__m128h __A, __m128h __B) {
305 // CHECK-LABEL: @test_mm_div_ph
306 // CHECK: %{{.*}} = fdiv <8 x half> %{{.*}}, %{{.*}}
307 return _mm_div_ph(__A, __B);
308 }
309
310 __m128h test_mm_mask_div_ph(__m128h __W, __mmask32 __U, __m128h __A, __m128h __B) {
311 // CHECK-LABEL: @test_mm_mask_div_ph
312 // CHECK: %{{.*}} = fdiv <8 x half> %{{.*}}, %{{.*}}
313 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
314 return (__m128h)_mm_mask_div_ph(__W, __U, __A, __B);
315 }
316
317 __m128h test_mm_maskz_div_ph(__mmask32 __U, __m128h __A, __m128h __B) {
318 // CHECK-LABEL: @test_mm_maskz_div_ph
319 // CHECK: %{{.*}} = fdiv <8 x half> %{{.*}}, %{{.*}}
320 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
321 return _mm_maskz_div_ph(__U, __A, __B);
322 }
323
324 __m256h test_mm256_min_ph(__m256h __A, __m256h __B) {
325 // CHECK-LABEL: @test_mm256_min_ph
326 // CHECK: @llvm.x86.avx512fp16.min.ph.256
327 return _mm256_min_ph(__A, __B);
328 }
329
330 __m256h test_mm256_mask_min_ph(__m256h __W, __mmask32 __U, __m256h __A, __m256h __B) {
331 // CHECK-LABEL: @test_mm256_mask_min_ph
332 // CHECK: @llvm.x86.avx512fp16.min.ph.256
333 return (__m256h)_mm256_mask_min_ph(__W, __U, __A, __B);
334 }
335
336 __m256h test_mm256_maskz_min_ph(__mmask32 __U, __m256h __A, __m256h __B) {
337 // CHECK-LABEL: @test_mm256_maskz_min_ph
338 // CHECK: @llvm.x86.avx512fp16.min.ph.256
339 return _mm256_maskz_min_ph(__U, __A, __B);
340 }
341
342 __m128h test_mm_min_ph(__m128h __A, __m128h __B) {
343 // CHECK-LABEL: @test_mm_min_ph
344 // CHECK: @llvm.x86.avx512fp16.min.ph.128
345 return _mm_min_ph(__A, __B);
346 }
347
348 __m128h test_mm_mask_min_ph(__m128h __W, __mmask32 __U, __m128h __A, __m128h __B) {
349 // CHECK-LABEL: @test_mm_mask_min_ph
350 // CHECK: @llvm.x86.avx512fp16.min.ph.128
351 return (__m128h)_mm_mask_min_ph(__W, __U, __A, __B);
352 }
353
354 __m128h test_mm_maskz_min_ph(__mmask32 __U, __m128h __A, __m128h __B) {
355 // CHECK-LABEL: @test_mm_maskz_min_ph
356 // CHECK: @llvm.x86.avx512fp16.min.ph.128
357 return _mm_maskz_min_ph(__U, __A, __B);
358 }
359
360 __m256h test_mm256_max_ph(__m256h __A, __m256h __B) {
361 // CHECK-LABEL: @test_mm256_max_ph
362 // CHECK: @llvm.x86.avx512fp16.max.ph.256
363 return _mm256_max_ph(__A, __B);
364 }
365
366 __m256h test_mm256_mask_max_ph(__m256h __W, __mmask32 __U, __m256h __A, __m256h __B) {
367 // CHECK-LABEL: @test_mm256_mask_max_ph
368 // CHECK: @llvm.x86.avx512fp16.max.ph.256
369 return (__m256h)_mm256_mask_max_ph(__W, __U, __A, __B);
370 }
371
372 __m256h test_mm256_maskz_max_ph(__mmask32 __U, __m256h __A, __m256h __B) {
373 // CHECK-LABEL: @test_mm256_maskz_max_ph
374 // CHECK: @llvm.x86.avx512fp16.max.ph.256
375 return _mm256_maskz_max_ph(__U, __A, __B);
376 }
377
378 __m128h test_mm_max_ph(__m128h __A, __m128h __B) {
379 // CHECK-LABEL: @test_mm_max_ph
380 // CHECK: @llvm.x86.avx512fp16.max.ph.128
381 return _mm_max_ph(__A, __B);
382 }
383
384 __m128h test_mm_mask_max_ph(__m128h __W, __mmask32 __U, __m128h __A, __m128h __B) {
385 // CHECK-LABEL: @test_mm_mask_max_ph
386 // CHECK: @llvm.x86.avx512fp16.max.ph.128
387 return (__m128h)_mm_mask_max_ph(__W, __U, __A, __B);
388 }
389
390 __m128h test_mm_maskz_max_ph(__mmask32 __U, __m128h __A, __m128h __B) {
391 // CHECK-LABEL: @test_mm_maskz_max_ph
392 // CHECK: @llvm.x86.avx512fp16.max.ph.128
393 return _mm_maskz_max_ph(__U, __A, __B);
394 }
395
396 __m128h test_mm_abs_ph(__m128h a) {
397 // CHECK-LABEL: @test_mm_abs_ph
398 // CHECK: and <4 x i32>
399 return _mm_abs_ph(a);
400 }
401
402 __m256h test_mm256_abs_ph(__m256h a) {
403 // CHECK-LABEL: @test_mm256_abs_ph
404 // CHECK: and <8 x i32>
405 return _mm256_abs_ph(a);
406 }
407
408 __m256h test_mm256_conj_pch(__m256h __A) {
409 // CHECK-LABEL: @test_mm256_conj_pch
410 // CHECK: %{{.*}} = bitcast <16 x half> %{{.*}} to <8 x float>
411 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <8 x i32>
412 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <8 x i32>
413 // CHECK: %{{.*}} = xor <8 x i32> %{{.*}}, %{{.*}}
414 // CHECK: %{{.*}} = bitcast <8 x i32> %{{.*}} to <8 x float>
415 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <16 x half>
416 return _mm256_conj_pch(__A);
417 }
418
419 __m256h test_mm256_mask_conj_pch(__m256h __W, __mmask32 __U, __m256h __A) {
420 // CHECK-LABEL: @test_mm256_mask_conj_pch
421 // CHECK: %{{.*}} = trunc i32 %{{.*}} to i8
422 // CHECK: %{{.*}} = bitcast <16 x half> %{{.*}} to <8 x float>
423 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <8 x i32>
424 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <8 x i32>
425 // CHECK: %{{.*}} = xor <8 x i32> %{{.*}}, %{{.*}}
426 // CHECK: %{{.*}} = bitcast <8 x i32> %{{.*}} to <8 x float>
427 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <16 x half>
428 // CHECK: %{{.*}} = bitcast <16 x half> %{{.*}} to <8 x float>
429 // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
430 // CHECK: %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
431 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <16 x half>
432 return _mm256_mask_conj_pch(__W, __U, __A);
433 }
434
435 __m256h test_mm256_maskz_conj_pch(__mmask32 __U, __m256h __A) {
436 // CHECK-LABEL: @test_mm256_maskz_conj_pch
437 // CHECK: %{{.*}} = trunc i32 %{{.*}} to i8
438 // CHECK: %{{.*}} = bitcast <16 x half> %{{.*}} to <8 x float>
439 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <8 x i32>
440 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <8 x i32>
441 // CHECK: %{{.*}} = xor <8 x i32> %{{.*}}, %{{.*}}
442 // CHECK: %{{.*}} = bitcast <8 x i32> %{{.*}} to <8 x float>
443 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <16 x half>
444 // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
445 // CHECK: %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
446 // CHECK: %{{.*}} = bitcast <8 x float> %{{.*}} to <16 x half>
447 return _mm256_maskz_conj_pch(__U, __A);
448 }
449
450 __m128h test_mm_conj_pch(__m128h __A) {
451 // CHECK-LABEL: @test_mm_conj_pch
452 // CHECK: %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
453 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <4 x i32>
454 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <4 x i32>
455 // CHECK: %{{.*}} = xor <4 x i32> %{{.*}}, %{{.*}}
456 // CHECK: %{{.*}} = bitcast <4 x i32> %{{.*}} to <4 x float>
457 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
458 return _mm_conj_pch(__A);
459 }
460
461 __m128h test_mm_mask_conj_pch(__m128h __W, __mmask32 __U, __m128h __A) {
462 // CHECK-LABEL: @test_mm_mask_conj_pch
463 // CHECK: %{{.*}} = trunc i32 %{{.*}} to i8
464 // CHECK: %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
465 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <4 x i32>
466 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <4 x i32>
467 // CHECK: %{{.*}} = xor <4 x i32> %{{.*}}, %{{.*}}
468 // CHECK: %{{.*}} = bitcast <4 x i32> %{{.*}} to <4 x float>
469 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
470 // CHECK: %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
471 // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
472 // CHECK: %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
473 // CHECK: %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
474 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
475 return _mm_mask_conj_pch(__W, __U, __A);
476 }
477
478 __m128h test_mm_maskz_conj_pch(__mmask32 __U, __m128h __A) {
479 // CHECK-LABEL: @test_mm_maskz_conj_pch
480 // CHECK: %{{.*}} = trunc i32 %{{.*}} to i8
481 // CHECK: %{{.*}} = bitcast <8 x half> %{{.*}} to <4 x float>
482 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <4 x i32>
483 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <4 x i32>
484 // CHECK: %{{.*}} = xor <4 x i32> %{{.*}}, %{{.*}}
485 // CHECK: %{{.*}} = bitcast <4 x i32> %{{.*}} to <4 x float>
486 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
487 // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
488 // CHECK: %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
489 // CHECK: %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
490 // CHECK: %{{.*}} = bitcast <4 x float> %{{.*}} to <8 x half>
491 return _mm_maskz_conj_pch(__U, __A);
492 }
493
494 __mmask16 test_mm256_cmp_ph_mask_eq_oq(__m256h a, __m256h b) {
495 // CHECK-LABEL: @test_mm256_cmp_ph_mask_eq_oq
496 // CHECK: fcmp oeq <16 x half> %{{.*}}, %{{.*}}
497 return _mm256_cmp_ph_mask(a, b, _CMP_EQ_OQ);
498 }
499
500 __mmask16 test_mm256_cmp_ph_mask_lt_os(__m256h a, __m256h b) {
501 // CHECK-LABEL: test_mm256_cmp_ph_mask_lt_os
502 // CHECK: fcmp olt <16 x half> %{{.*}}, %{{.*}}
503 return _mm256_cmp_ph_mask(a, b, _CMP_LT_OS);
504 }
505
506 __mmask16 test_mm256_cmp_ph_mask_le_os(__m256h a, __m256h b) {
507 // CHECK-LABEL: test_mm256_cmp_ph_mask_le_os
508 // CHECK: fcmp ole <16 x half> %{{.*}}, %{{.*}}
509 return _mm256_cmp_ph_mask(a, b, _CMP_LE_OS);
510 }
511
512 __mmask16 test_mm256_cmp_ph_mask_unord_q(__m256h a, __m256h b) {
513 // CHECK-LABEL: test_mm256_cmp_ph_mask_unord_q
514 // CHECK: fcmp uno <16 x half> %{{.*}}, %{{.*}}
515 return _mm256_cmp_ph_mask(a, b, _CMP_UNORD_Q);
516 }
517
518 __mmask16 test_mm256_cmp_ph_mask_neq_uq(__m256h a, __m256h b) {
519 // CHECK-LABEL: test_mm256_cmp_ph_mask_neq_uq
520 // CHECK: fcmp une <16 x half> %{{.*}}, %{{.*}}
521 return _mm256_cmp_ph_mask(a, b, _CMP_NEQ_UQ);
522 }
523
524 __mmask16 test_mm256_cmp_ph_mask_nlt_us(__m256h a, __m256h b) {
525 // CHECK-LABEL: test_mm256_cmp_ph_mask_nlt_us
526 // CHECK: fcmp uge <16 x half> %{{.*}}, %{{.*}}
527 return _mm256_cmp_ph_mask(a, b, _CMP_NLT_US);
528 }
529
530 __mmask16 test_mm256_cmp_ph_mask_nle_us(__m256h a, __m256h b) {
531 // CHECK-LABEL: test_mm256_cmp_ph_mask_nle_us
532 // CHECK: fcmp ugt <16 x half> %{{.*}}, %{{.*}}
533 return _mm256_cmp_ph_mask(a, b, _CMP_NLE_US);
534 }
535
536 __mmask16 test_mm256_cmp_ph_mask_ord_q(__m256h a, __m256h b) {
537 // CHECK-LABEL: test_mm256_cmp_ph_mask_ord_q
538 // CHECK: fcmp ord <16 x half> %{{.*}}, %{{.*}}
539 return _mm256_cmp_ph_mask(a, b, _CMP_ORD_Q);
540 }
541
542 __mmask16 test_mm256_cmp_ph_mask_eq_uq(__m256h a, __m256h b) {
543 // CHECK-LABEL: test_mm256_cmp_ph_mask_eq_uq
544 // CHECK: fcmp ueq <16 x half> %{{.*}}, %{{.*}}
545 return _mm256_cmp_ph_mask(a, b, _CMP_EQ_UQ);
546 }
547
548 __mmask16 test_mm256_cmp_ph_mask_nge_us(__m256h a, __m256h b) {
549 // CHECK-LABEL: test_mm256_cmp_ph_mask_nge_us
550 // CHECK: fcmp ult <16 x half> %{{.*}}, %{{.*}}
551 return _mm256_cmp_ph_mask(a, b, _CMP_NGE_US);
552 }
553
554 __mmask16 test_mm256_cmp_ph_mask_ngt_us(__m256h a, __m256h b) {
555 // CHECK-LABEL: test_mm256_cmp_ph_mask_ngt_us
556 // CHECK: fcmp ule <16 x half> %{{.*}}, %{{.*}}
557 return _mm256_cmp_ph_mask(a, b, _CMP_NGT_US);
558 }
559
560 __mmask16 test_mm256_cmp_ph_mask_false_oq(__m256h a, __m256h b) {
561 // CHECK-LABEL: test_mm256_cmp_ph_mask_false_oq
562 // CHECK: fcmp false <16 x half> %{{.*}}, %{{.*}}
563 return _mm256_cmp_ph_mask(a, b, _CMP_FALSE_OQ);
564 }
565
566 __mmask16 test_mm256_cmp_ph_mask_neq_oq(__m256h a, __m256h b) {
567 // CHECK-LABEL: test_mm256_cmp_ph_mask_neq_oq
568 // CHECK: fcmp one <16 x half> %{{.*}}, %{{.*}}
569 return _mm256_cmp_ph_mask(a, b, _CMP_NEQ_OQ);
570 }
571
572 __mmask16 test_mm256_cmp_ph_mask_ge_os(__m256h a, __m256h b) {
573 // CHECK-LABEL: test_mm256_cmp_ph_mask_ge_os
574 // CHECK: fcmp oge <16 x half> %{{.*}}, %{{.*}}
575 return _mm256_cmp_ph_mask(a, b, _CMP_GE_OS);
576 }
577
578 __mmask16 test_mm256_cmp_ph_mask_gt_os(__m256h a, __m256h b) {
579 // CHECK-LABEL: test_mm256_cmp_ph_mask_gt_os
580 // CHECK: fcmp ogt <16 x half> %{{.*}}, %{{.*}}
581 return _mm256_cmp_ph_mask(a, b, _CMP_GT_OS);
582 }
583
584 __mmask16 test_mm256_cmp_ph_mask_true_uq(__m256h a, __m256h b) {
585 // CHECK-LABEL: test_mm256_cmp_ph_mask_true_uq
586 // CHECK: fcmp true <16 x half> %{{.*}}, %{{.*}}
587 return _mm256_cmp_ph_mask(a, b, _CMP_TRUE_UQ);
588 }
589
590 __mmask16 test_mm256_cmp_ph_mask_eq_os(__m256h a, __m256h b) {
591 // CHECK-LABEL: test_mm256_cmp_ph_mask_eq_os
592 // CHECK: fcmp oeq <16 x half> %{{.*}}, %{{.*}}
593 return _mm256_cmp_ph_mask(a, b, _CMP_EQ_OS);
594 }
595
596 __mmask16 test_mm256_cmp_ph_mask_lt_oq(__m256h a, __m256h b) {
597 // CHECK-LABEL: test_mm256_cmp_ph_mask_lt_oq
598 // CHECK: fcmp olt <16 x half> %{{.*}}, %{{.*}}
599 return _mm256_cmp_ph_mask(a, b, _CMP_LT_OQ);
600 }
601
602 __mmask16 test_mm256_cmp_ph_mask_le_oq(__m256h a, __m256h b) {
603 // CHECK-LABEL: test_mm256_cmp_ph_mask_le_oq
604 // CHECK: fcmp ole <16 x half> %{{.*}}, %{{.*}}
605 return _mm256_cmp_ph_mask(a, b, _CMP_LE_OQ);
606 }
607
608 __mmask16 test_mm256_cmp_ph_mask_unord_s(__m256h a, __m256h b) {
609 // CHECK-LABEL: test_mm256_cmp_ph_mask_unord_s
610 // CHECK: fcmp uno <16 x half> %{{.*}}, %{{.*}}
611 return _mm256_cmp_ph_mask(a, b, _CMP_UNORD_S);
612 }
613
614 __mmask16 test_mm256_cmp_ph_mask_neq_us(__m256h a, __m256h b) {
615 // CHECK-LABEL: test_mm256_cmp_ph_mask_neq_us
616 // CHECK: fcmp une <16 x half> %{{.*}}, %{{.*}}
617 return _mm256_cmp_ph_mask(a, b, _CMP_NEQ_US);
618 }
619
620 __mmask16 test_mm256_cmp_ph_mask_nlt_uq(__m256h a, __m256h b) {
621 // CHECK-LABEL: test_mm256_cmp_ph_mask_nlt_uq
622 // CHECK: fcmp uge <16 x half> %{{.*}}, %{{.*}}
623 return _mm256_cmp_ph_mask(a, b, _CMP_NLT_UQ);
624 }
625
626 __mmask16 test_mm256_cmp_ph_mask_nle_uq(__m256h a, __m256h b) {
627 // CHECK-LABEL: test_mm256_cmp_ph_mask_nle_uq
628 // CHECK: fcmp ugt <16 x half> %{{.*}}, %{{.*}}
629 return _mm256_cmp_ph_mask(a, b, _CMP_NLE_UQ);
630 }
631
632 __mmask16 test_mm256_cmp_ph_mask_ord_s(__m256h a, __m256h b) {
633 // CHECK-LABEL: test_mm256_cmp_ph_mask_ord_s
634 // CHECK: fcmp ord <16 x half> %{{.*}}, %{{.*}}
635 return _mm256_cmp_ph_mask(a, b, _CMP_ORD_S);
636 }
637
638 __mmask16 test_mm256_cmp_ph_mask_eq_us(__m256h a, __m256h b) {
639 // CHECK-LABEL: test_mm256_cmp_ph_mask_eq_us
640 // CHECK: fcmp ueq <16 x half> %{{.*}}, %{{.*}}
641 return _mm256_cmp_ph_mask(a, b, _CMP_EQ_US);
642 }
643
644 __mmask16 test_mm256_cmp_ph_mask_nge_uq(__m256h a, __m256h b) {
645 // CHECK-LABEL: test_mm256_cmp_ph_mask_nge_uq
646 // CHECK: fcmp ult <16 x half> %{{.*}}, %{{.*}}
647 return _mm256_cmp_ph_mask(a, b, _CMP_NGE_UQ);
648 }
649
650 __mmask16 test_mm256_cmp_ph_mask_ngt_uq(__m256h a, __m256h b) {
651 // CHECK-LABEL: test_mm256_cmp_ph_mask_ngt_uq
652 // CHECK: fcmp ule <16 x half> %{{.*}}, %{{.*}}
653 return _mm256_cmp_ph_mask(a, b, _CMP_NGT_UQ);
654 }
655
656 __mmask16 test_mm256_cmp_ph_mask_false_os(__m256h a, __m256h b) {
657 // CHECK-LABEL: test_mm256_cmp_ph_mask_false_os
658 // CHECK: fcmp false <16 x half> %{{.*}}, %{{.*}}
659 return _mm256_cmp_ph_mask(a, b, _CMP_FALSE_OS);
660 }
661
662 __mmask16 test_mm256_cmp_ph_mask_neq_os(__m256h a, __m256h b) {
663 // CHECK-LABEL: test_mm256_cmp_ph_mask_neq_os
664 // CHECK: fcmp one <16 x half> %{{.*}}, %{{.*}}
665 return _mm256_cmp_ph_mask(a, b, _CMP_NEQ_OS);
666 }
667
668 __mmask16 test_mm256_cmp_ph_mask_ge_oq(__m256h a, __m256h b) {
669 // CHECK-LABEL: test_mm256_cmp_ph_mask_ge_oq
670 // CHECK: fcmp oge <16 x half> %{{.*}}, %{{.*}}
671 return _mm256_cmp_ph_mask(a, b, _CMP_GE_OQ);
672 }
673
674 __mmask16 test_mm256_cmp_ph_mask_gt_oq(__m256h a, __m256h b) {
675 // CHECK-LABEL: test_mm256_cmp_ph_mask_gt_oq
676 // CHECK: fcmp ogt <16 x half> %{{.*}}, %{{.*}}
677 return _mm256_cmp_ph_mask(a, b, _CMP_GT_OQ);
678 }
679
680 __mmask16 test_mm256_cmp_ph_mask_true_us(__m256h a, __m256h b) {
681 // CHECK-LABEL: test_mm256_cmp_ph_mask_true_us
682 // CHECK: fcmp true <16 x half> %{{.*}}, %{{.*}}
683 return _mm256_cmp_ph_mask(a, b, _CMP_TRUE_US);
684 }
685
686 __mmask16 test_mm256_mask_cmp_ph_mask_eq_oq(__mmask16 m, __m256h a, __m256h b) {
687 // CHECK-LABEL: @test_mm256_mask_cmp_ph_mask_eq_oq
688 // CHECK: [[CMP:%.*]] = fcmp oeq <16 x half> %{{.*}}, %{{.*}}
689 // CHECK: and <16 x i1> [[CMP]], {{.*}}
690 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OQ);
691 }
692
693 __mmask16 test_mm256_mask_cmp_ph_mask_lt_os(__mmask16 m, __m256h a, __m256h b) {
694 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_lt_os
695 // CHECK: [[CMP:%.*]] = fcmp olt <16 x half> %{{.*}}, %{{.*}}
696 // CHECK: and <16 x i1> [[CMP]], {{.*}}
697 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_LT_OS);
698 }
699
700 __mmask16 test_mm256_mask_cmp_ph_mask_le_os(__mmask16 m, __m256h a, __m256h b) {
701 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_le_os
702 // CHECK: [[CMP:%.*]] = fcmp ole <16 x half> %{{.*}}, %{{.*}}
703 // CHECK: and <16 x i1> [[CMP]], {{.*}}
704 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_LE_OS);
705 }
706
707 __mmask16 test_mm256_mask_cmp_ph_mask_unord_q(__mmask16 m, __m256h a, __m256h b) {
708 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_unord_q
709 // CHECK: [[CMP:%.*]] = fcmp uno <16 x half> %{{.*}}, %{{.*}}
710 // CHECK: and <16 x i1> [[CMP]], {{.*}}
711 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_Q);
712 }
713
714 __mmask16 test_mm256_mask_cmp_ph_mask_neq_uq(__mmask16 m, __m256h a, __m256h b) {
715 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_neq_uq
716 // CHECK: [[CMP:%.*]] = fcmp une <16 x half> %{{.*}}, %{{.*}}
717 // CHECK: and <16 x i1> [[CMP]], {{.*}}
718 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_UQ);
719 }
720
721 __mmask16 test_mm256_mask_cmp_ph_mask_nlt_us(__mmask16 m, __m256h a, __m256h b) {
722 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_nlt_us
723 // CHECK: [[CMP:%.*]] = fcmp uge <16 x half> %{{.*}}, %{{.*}}
724 // CHECK: and <16 x i1> [[CMP]], {{.*}}
725 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NLT_US);
726 }
727
728 __mmask16 test_mm256_mask_cmp_ph_mask_nle_us(__mmask16 m, __m256h a, __m256h b) {
729 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_nle_us
730 // CHECK: [[CMP:%.*]] = fcmp ugt <16 x half> %{{.*}}, %{{.*}}
731 // CHECK: and <16 x i1> [[CMP]], {{.*}}
732 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NLE_US);
733 }
734
735 __mmask16 test_mm256_mask_cmp_ph_mask_ord_q(__mmask16 m, __m256h a, __m256h b) {
736 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_ord_q
737 // CHECK: [[CMP:%.*]] = fcmp ord <16 x half> %{{.*}}, %{{.*}}
738 // CHECK: and <16 x i1> [[CMP]], {{.*}}
739 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_ORD_Q);
740 }
741
742 __mmask16 test_mm256_mask_cmp_ph_mask_eq_uq(__mmask16 m, __m256h a, __m256h b) {
743 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_eq_uq
744 // CHECK: [[CMP:%.*]] = fcmp ueq <16 x half> %{{.*}}, %{{.*}}
745 // CHECK: and <16 x i1> [[CMP]], {{.*}}
746 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_EQ_UQ);
747 }
748
749 __mmask16 test_mm256_mask_cmp_ph_mask_nge_us(__mmask16 m, __m256h a, __m256h b) {
750 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_nge_us
751 // CHECK: [[CMP:%.*]] = fcmp ult <16 x half> %{{.*}}, %{{.*}}
752 // CHECK: and <16 x i1> [[CMP]], {{.*}}
753 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NGE_US);
754 }
755
756 __mmask16 test_mm256_mask_cmp_ph_mask_ngt_us(__mmask16 m, __m256h a, __m256h b) {
757 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_ngt_us
758 // CHECK: [[CMP:%.*]] = fcmp ule <16 x half> %{{.*}}, %{{.*}}
759 // CHECK: and <16 x i1> [[CMP]], {{.*}}
760 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NGT_US);
761 }
762
763 __mmask16 test_mm256_mask_cmp_ph_mask_false_oq(__mmask16 m, __m256h a, __m256h b) {
764 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_false_oq
765 // CHECK: [[CMP:%.*]] = fcmp false <16 x half> %{{.*}}, %{{.*}}
766 // CHECK: and <16 x i1> [[CMP]], {{.*}}
767 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OQ);
768 }
769
770 __mmask16 test_mm256_mask_cmp_ph_mask_neq_oq(__mmask16 m, __m256h a, __m256h b) {
771 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_neq_oq
772 // CHECK: [[CMP:%.*]] = fcmp one <16 x half> %{{.*}}, %{{.*}}
773 // CHECK: and <16 x i1> [[CMP]], {{.*}}
774 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OQ);
775 }
776
777 __mmask16 test_mm256_mask_cmp_ph_mask_ge_os(__mmask16 m, __m256h a, __m256h b) {
778 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_ge_os
779 // CHECK: [[CMP:%.*]] = fcmp oge <16 x half> %{{.*}}, %{{.*}}
780 // CHECK: and <16 x i1> [[CMP]], {{.*}}
781 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_GE_OS);
782 }
783
784 __mmask16 test_mm256_mask_cmp_ph_mask_gt_os(__mmask16 m, __m256h a, __m256h b) {
785 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_gt_os
786 // CHECK: [[CMP:%.*]] = fcmp ogt <16 x half> %{{.*}}, %{{.*}}
787 // CHECK: and <16 x i1> [[CMP]], {{.*}}
788 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_GT_OS);
789 }
790
791 __mmask16 test_mm256_mask_cmp_ph_mask_true_uq(__mmask16 m, __m256h a, __m256h b) {
792 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_true_uq
793 // CHECK: [[CMP:%.*]] = fcmp true <16 x half> %{{.*}}, %{{.*}}
794 // CHECK: and <16 x i1> [[CMP]], {{.*}}
795 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_UQ);
796 }
797
798 __mmask16 test_mm256_mask_cmp_ph_mask_eq_os(__mmask16 m, __m256h a, __m256h b) {
799 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_eq_os
800 // CHECK: [[CMP:%.*]] = fcmp oeq <16 x half> %{{.*}}, %{{.*}}
801 // CHECK: and <16 x i1> [[CMP]], {{.*}}
802 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OS);
803 }
804
805 __mmask16 test_mm256_mask_cmp_ph_mask_lt_oq(__mmask16 m, __m256h a, __m256h b) {
806 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_lt_oq
807 // CHECK: [[CMP:%.*]] = fcmp olt <16 x half> %{{.*}}, %{{.*}}
808 // CHECK: and <16 x i1> [[CMP]], {{.*}}
809 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_LT_OQ);
810 }
811
812 __mmask16 test_mm256_mask_cmp_ph_mask_le_oq(__mmask16 m, __m256h a, __m256h b) {
813 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_le_oq
814 // CHECK: [[CMP:%.*]] = fcmp ole <16 x half> %{{.*}}, %{{.*}}
815 // CHECK: and <16 x i1> [[CMP]], {{.*}}
816 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_LE_OQ);
817 }
818
819 __mmask16 test_mm256_mask_cmp_ph_mask_unord_s(__mmask16 m, __m256h a, __m256h b) {
820 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_unord_s
821 // CHECK: [[CMP:%.*]] = fcmp uno <16 x half> %{{.*}}, %{{.*}}
822 // CHECK: and <16 x i1> [[CMP]], {{.*}}
823 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_S);
824 }
825
826 __mmask16 test_mm256_mask_cmp_ph_mask_neq_us(__mmask16 m, __m256h a, __m256h b) {
827 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_neq_us
828 // CHECK: [[CMP:%.*]] = fcmp une <16 x half> %{{.*}}, %{{.*}}
829 // CHECK: and <16 x i1> [[CMP]], {{.*}}
830 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_US);
831 }
832
833 __mmask16 test_mm256_mask_cmp_ph_mask_nlt_uq(__mmask16 m, __m256h a, __m256h b) {
834 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_nlt_uq
835 // CHECK: [[CMP:%.*]] = fcmp uge <16 x half> %{{.*}}, %{{.*}}
836 // CHECK: and <16 x i1> [[CMP]], {{.*}}
837 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NLT_UQ);
838 }
839
840 __mmask16 test_mm256_mask_cmp_ph_mask_nle_uq(__mmask16 m, __m256h a, __m256h b) {
841 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_nle_uq
842 // CHECK: [[CMP:%.*]] = fcmp ugt <16 x half> %{{.*}}, %{{.*}}
843 // CHECK: and <16 x i1> [[CMP]], {{.*}}
844 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NLE_UQ);
845 }
846
847 __mmask16 test_mm256_mask_cmp_ph_mask_ord_s(__mmask16 m, __m256h a, __m256h b) {
848 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_ord_s
849 // CHECK: [[CMP:%.*]] = fcmp ord <16 x half> %{{.*}}, %{{.*}}
850 // CHECK: and <16 x i1> [[CMP]], {{.*}}
851 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_ORD_S);
852 }
853
854 __mmask16 test_mm256_mask_cmp_ph_mask_eq_us(__mmask16 m, __m256h a, __m256h b) {
855 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_eq_us
856 // CHECK: [[CMP:%.*]] = fcmp ueq <16 x half> %{{.*}}, %{{.*}}
857 // CHECK: and <16 x i1> [[CMP]], {{.*}}
858 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_EQ_US);
859 }
860
861 __mmask16 test_mm256_mask_cmp_ph_mask_nge_uq(__mmask16 m, __m256h a, __m256h b) {
862 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_nge_uq
863 // CHECK: [[CMP:%.*]] = fcmp ult <16 x half> %{{.*}}, %{{.*}}
864 // CHECK: and <16 x i1> [[CMP]], {{.*}}
865 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NGE_UQ);
866 }
867
868 __mmask16 test_mm256_mask_cmp_ph_mask_ngt_uq(__mmask16 m, __m256h a, __m256h b) {
869 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_ngt_uq
870 // CHECK: [[CMP:%.*]] = fcmp ule <16 x half> %{{.*}}, %{{.*}}
871 // CHECK: and <16 x i1> [[CMP]], {{.*}}
872 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NGT_UQ);
873 }
874
875 __mmask16 test_mm256_mask_cmp_ph_mask_false_os(__mmask16 m, __m256h a, __m256h b) {
876 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_false_os
877 // CHECK: [[CMP:%.*]] = fcmp false <16 x half> %{{.*}}, %{{.*}}
878 // CHECK: and <16 x i1> [[CMP]], {{.*}}
879 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OS);
880 }
881
882 __mmask16 test_mm256_mask_cmp_ph_mask_neq_os(__mmask16 m, __m256h a, __m256h b) {
883 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_neq_os
884 // CHECK: [[CMP:%.*]] = fcmp one <16 x half> %{{.*}}, %{{.*}}
885 // CHECK: and <16 x i1> [[CMP]], {{.*}}
886 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OS);
887 }
888
889 __mmask16 test_mm256_mask_cmp_ph_mask_ge_oq(__mmask16 m, __m256h a, __m256h b) {
890 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_ge_oq
891 // CHECK: [[CMP:%.*]] = fcmp oge <16 x half> %{{.*}}, %{{.*}}
892 // CHECK: and <16 x i1> [[CMP]], {{.*}}
893 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_GE_OQ);
894 }
895
896 __mmask16 test_mm256_mask_cmp_ph_mask_gt_oq(__mmask16 m, __m256h a, __m256h b) {
897 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_gt_oq
898 // CHECK: [[CMP:%.*]] = fcmp ogt <16 x half> %{{.*}}, %{{.*}}
899 // CHECK: and <16 x i1> [[CMP]], {{.*}}
900 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_GT_OQ);
901 }
902
903 __mmask16 test_mm256_mask_cmp_ph_mask_true_us(__mmask16 m, __m256h a, __m256h b) {
904 // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_true_us
905 // CHECK: [[CMP:%.*]] = fcmp true <16 x half> %{{.*}}, %{{.*}}
906 // CHECK: and <16 x i1> [[CMP]], {{.*}}
907 return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_US);
908 }
909
910 __mmask8 test_mm_cmp_ph_mask_eq_oq(__m128h a, __m128h b) {
911 // CHECK-LABEL: @test_mm_cmp_ph_mask_eq_oq
912 // CHECK: fcmp oeq <8 x half> %{{.*}}, %{{.*}}
913 return _mm_cmp_ph_mask(a, b, _CMP_EQ_OQ);
914 }
915
916 __mmask8 test_mm_cmp_ph_mask_lt_os(__m128h a, __m128h b) {
917 // CHECK-LABEL: test_mm_cmp_ph_mask_lt_os
918 // CHECK: fcmp olt <8 x half> %{{.*}}, %{{.*}}
919 return _mm_cmp_ph_mask(a, b, _CMP_LT_OS);
920 }
921
922 __mmask8 test_mm_cmp_ph_mask_le_os(__m128h a, __m128h b) {
923 // CHECK-LABEL: test_mm_cmp_ph_mask_le_os
924 // CHECK: fcmp ole <8 x half> %{{.*}}, %{{.*}}
925 return _mm_cmp_ph_mask(a, b, _CMP_LE_OS);
926 }
927
928 __mmask8 test_mm_cmp_ph_mask_unord_q(__m128h a, __m128h b) {
929 // CHECK-LABEL: test_mm_cmp_ph_mask_unord_q
930 // CHECK: fcmp uno <8 x half> %{{.*}}, %{{.*}}
931 return _mm_cmp_ph_mask(a, b, _CMP_UNORD_Q);
932 }
933
934 __mmask8 test_mm_cmp_ph_mask_neq_uq(__m128h a, __m128h b) {
935 // CHECK-LABEL: test_mm_cmp_ph_mask_neq_uq
936 // CHECK: fcmp une <8 x half> %{{.*}}, %{{.*}}
937 return _mm_cmp_ph_mask(a, b, _CMP_NEQ_UQ);
938 }
939
940 __mmask8 test_mm_cmp_ph_mask_nlt_us(__m128h a, __m128h b) {
941 // CHECK-LABEL: test_mm_cmp_ph_mask_nlt_us
942 // CHECK: fcmp uge <8 x half> %{{.*}}, %{{.*}}
943 return _mm_cmp_ph_mask(a, b, _CMP_NLT_US);
944 }
945
946 __mmask8 test_mm_cmp_ph_mask_nle_us(__m128h a, __m128h b) {
947 // CHECK-LABEL: test_mm_cmp_ph_mask_nle_us
948 // CHECK: fcmp ugt <8 x half> %{{.*}}, %{{.*}}
949 return _mm_cmp_ph_mask(a, b, _CMP_NLE_US);
950 }
951
952 __mmask8 test_mm_cmp_ph_mask_ord_q(__m128h a, __m128h b) {
953 // CHECK-LABEL: test_mm_cmp_ph_mask_ord_q
954 // CHECK: fcmp ord <8 x half> %{{.*}}, %{{.*}}
955 return _mm_cmp_ph_mask(a, b, _CMP_ORD_Q);
956 }
957
958 __mmask8 test_mm_cmp_ph_mask_eq_uq(__m128h a, __m128h b) {
959 // CHECK-LABEL: test_mm_cmp_ph_mask_eq_uq
960 // CHECK: fcmp ueq <8 x half> %{{.*}}, %{{.*}}
961 return _mm_cmp_ph_mask(a, b, _CMP_EQ_UQ);
962 }
963
964 __mmask8 test_mm_cmp_ph_mask_nge_us(__m128h a, __m128h b) {
965 // CHECK-LABEL: test_mm_cmp_ph_mask_nge_us
966 // CHECK: fcmp ult <8 x half> %{{.*}}, %{{.*}}
967 return _mm_cmp_ph_mask(a, b, _CMP_NGE_US);
968 }
969
970 __mmask8 test_mm_cmp_ph_mask_ngt_us(__m128h a, __m128h b) {
971 // CHECK-LABEL: test_mm_cmp_ph_mask_ngt_us
972 // CHECK: fcmp ule <8 x half> %{{.*}}, %{{.*}}
973 return _mm_cmp_ph_mask(a, b, _CMP_NGT_US);
974 }
975
976 __mmask8 test_mm_cmp_ph_mask_false_oq(__m128h a, __m128h b) {
977 // CHECK-LABEL: test_mm_cmp_ph_mask_false_oq
978 // CHECK: fcmp false <8 x half> %{{.*}}, %{{.*}}
979 return _mm_cmp_ph_mask(a, b, _CMP_FALSE_OQ);
980 }
981
982 __mmask8 test_mm_cmp_ph_mask_neq_oq(__m128h a, __m128h b) {
983 // CHECK-LABEL: test_mm_cmp_ph_mask_neq_oq
984 // CHECK: fcmp one <8 x half> %{{.*}}, %{{.*}}
985 return _mm_cmp_ph_mask(a, b, _CMP_NEQ_OQ);
986 }
987
988 __mmask8 test_mm_cmp_ph_mask_ge_os(__m128h a, __m128h b) {
989 // CHECK-LABEL: test_mm_cmp_ph_mask_ge_os
990 // CHECK: fcmp oge <8 x half> %{{.*}}, %{{.*}}
991 return _mm_cmp_ph_mask(a, b, _CMP_GE_OS);
992 }
993
994 __mmask8 test_mm_cmp_ph_mask_gt_os(__m128h a, __m128h b) {
995 // CHECK-LABEL: test_mm_cmp_ph_mask_gt_os
996 // CHECK: fcmp ogt <8 x half> %{{.*}}, %{{.*}}
997 return _mm_cmp_ph_mask(a, b, _CMP_GT_OS);
998 }
999
1000 __mmask8 test_mm_cmp_ph_mask_true_uq(__m128h a, __m128h b) {
1001 // CHECK-LABEL: test_mm_cmp_ph_mask_true_uq
1002 // CHECK: fcmp true <8 x half> %{{.*}}, %{{.*}}
1003 return _mm_cmp_ph_mask(a, b, _CMP_TRUE_UQ);
1004 }
1005
1006 __mmask8 test_mm_cmp_ph_mask_eq_os(__m128h a, __m128h b) {
1007 // CHECK-LABEL: test_mm_cmp_ph_mask_eq_os
1008 // CHECK: fcmp oeq <8 x half> %{{.*}}, %{{.*}}
1009 return _mm_cmp_ph_mask(a, b, _CMP_EQ_OS);
1010 }
1011
1012 __mmask8 test_mm_cmp_ph_mask_lt_oq(__m128h a, __m128h b) {
1013 // CHECK-LABEL: test_mm_cmp_ph_mask_lt_oq
1014 // CHECK: fcmp olt <8 x half> %{{.*}}, %{{.*}}
1015 return _mm_cmp_ph_mask(a, b, _CMP_LT_OQ);
1016 }
1017
1018 __mmask8 test_mm_cmp_ph_mask_le_oq(__m128h a, __m128h b) {
1019 // CHECK-LABEL: test_mm_cmp_ph_mask_le_oq
1020 // CHECK: fcmp ole <8 x half> %{{.*}}, %{{.*}}
1021 return _mm_cmp_ph_mask(a, b, _CMP_LE_OQ);
1022 }
1023
1024 __mmask8 test_mm_cmp_ph_mask_unord_s(__m128h a, __m128h b) {
1025 // CHECK-LABEL: test_mm_cmp_ph_mask_unord_s
1026 // CHECK: fcmp uno <8 x half> %{{.*}}, %{{.*}}
1027 return _mm_cmp_ph_mask(a, b, _CMP_UNORD_S);
1028 }
1029
1030 __mmask8 test_mm_cmp_ph_mask_neq_us(__m128h a, __m128h b) {
1031 // CHECK-LABEL: test_mm_cmp_ph_mask_neq_us
1032 // CHECK: fcmp une <8 x half> %{{.*}}, %{{.*}}
1033 return _mm_cmp_ph_mask(a, b, _CMP_NEQ_US);
1034 }
1035
1036 __mmask8 test_mm_cmp_ph_mask_nlt_uq(__m128h a, __m128h b) {
1037 // CHECK-LABEL: test_mm_cmp_ph_mask_nlt_uq
1038 // CHECK: fcmp uge <8 x half> %{{.*}}, %{{.*}}
1039 return _mm_cmp_ph_mask(a, b, _CMP_NLT_UQ);
1040 }
1041
1042 __mmask8 test_mm_cmp_ph_mask_nle_uq(__m128h a, __m128h b) {
1043 // CHECK-LABEL: test_mm_cmp_ph_mask_nle_uq
1044 // CHECK: fcmp ugt <8 x half> %{{.*}}, %{{.*}}
1045 return _mm_cmp_ph_mask(a, b, _CMP_NLE_UQ);
1046 }
1047
1048 __mmask8 test_mm_cmp_ph_mask_ord_s(__m128h a, __m128h b) {
1049 // CHECK-LABEL: test_mm_cmp_ph_mask_ord_s
1050 // CHECK: fcmp ord <8 x half> %{{.*}}, %{{.*}}
1051 return _mm_cmp_ph_mask(a, b, _CMP_ORD_S);
1052 }
1053
1054 __mmask8 test_mm_cmp_ph_mask_eq_us(__m128h a, __m128h b) {
1055 // CHECK-LABEL: test_mm_cmp_ph_mask_eq_us
1056 // CHECK: fcmp ueq <8 x half> %{{.*}}, %{{.*}}
1057 return _mm_cmp_ph_mask(a, b, _CMP_EQ_US);
1058 }
1059
1060 __mmask8 test_mm_cmp_ph_mask_nge_uq(__m128h a, __m128h b) {
1061 // CHECK-LABEL: test_mm_cmp_ph_mask_nge_uq
1062 // CHECK: fcmp ult <8 x half> %{{.*}}, %{{.*}}
1063 return _mm_cmp_ph_mask(a, b, _CMP_NGE_UQ);
1064 }
1065
1066 __mmask8 test_mm_cmp_ph_mask_ngt_uq(__m128h a, __m128h b) {
1067 // CHECK-LABEL: test_mm_cmp_ph_mask_ngt_uq
1068 // CHECK: fcmp ule <8 x half> %{{.*}}, %{{.*}}
1069 return _mm_cmp_ph_mask(a, b, _CMP_NGT_UQ);
1070 }
1071
1072 __mmask8 test_mm_cmp_ph_mask_false_os(__m128h a, __m128h b) {
1073 // CHECK-LABEL: test_mm_cmp_ph_mask_false_os
1074 // CHECK: fcmp false <8 x half> %{{.*}}, %{{.*}}
1075 return _mm_cmp_ph_mask(a, b, _CMP_FALSE_OS);
1076 }
1077
1078 __mmask8 test_mm_cmp_ph_mask_neq_os(__m128h a, __m128h b) {
1079 // CHECK-LABEL: test_mm_cmp_ph_mask_neq_os
1080 // CHECK: fcmp one <8 x half> %{{.*}}, %{{.*}}
1081 return _mm_cmp_ph_mask(a, b, _CMP_NEQ_OS);
1082 }
1083
1084 __mmask8 test_mm_cmp_ph_mask_ge_oq(__m128h a, __m128h b) {
1085 // CHECK-LABEL: test_mm_cmp_ph_mask_ge_oq
1086 // CHECK: fcmp oge <8 x half> %{{.*}}, %{{.*}}
1087 return _mm_cmp_ph_mask(a, b, _CMP_GE_OQ);
1088 }
1089
1090 __mmask8 test_mm_cmp_ph_mask_gt_oq(__m128h a, __m128h b) {
1091 // CHECK-LABEL: test_mm_cmp_ph_mask_gt_oq
1092 // CHECK: fcmp ogt <8 x half> %{{.*}}, %{{.*}}
1093 return _mm_cmp_ph_mask(a, b, _CMP_GT_OQ);
1094 }
1095
1096 __mmask8 test_mm_cmp_ph_mask_true_us(__m128h a, __m128h b) {
1097 // CHECK-LABEL: test_mm_cmp_ph_mask_true_us
1098 // CHECK: fcmp true <8 x half> %{{.*}}, %{{.*}}
1099 return _mm_cmp_ph_mask(a, b, _CMP_TRUE_US);
1100 }
1101
1102 __mmask8 test_mm_mask_cmp_ph_mask_eq_oq(__mmask8 m, __m128h a, __m128h b) {
1103 // CHECK-LABEL: @test_mm_mask_cmp_ph_mask_eq_oq
1104 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x half> %{{.*}}, %{{.*}}
1105 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1106 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OQ);
1107 }
1108
1109 __mmask8 test_mm_mask_cmp_ph_mask_lt_os(__mmask8 m, __m128h a, __m128h b) {
1110 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_lt_os
1111 // CHECK: [[CMP:%.*]] = fcmp olt <8 x half> %{{.*}}, %{{.*}}
1112 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1113 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_LT_OS);
1114 }
1115
1116 __mmask8 test_mm_mask_cmp_ph_mask_le_os(__mmask8 m, __m128h a, __m128h b) {
1117 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_le_os
1118 // CHECK: [[CMP:%.*]] = fcmp ole <8 x half> %{{.*}}, %{{.*}}
1119 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1120 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_LE_OS);
1121 }
1122
1123 __mmask8 test_mm_mask_cmp_ph_mask_unord_q(__mmask8 m, __m128h a, __m128h b) {
1124 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_unord_q
1125 // CHECK: [[CMP:%.*]] = fcmp uno <8 x half> %{{.*}}, %{{.*}}
1126 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1127 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_Q);
1128 }
1129
1130 __mmask8 test_mm_mask_cmp_ph_mask_neq_uq(__mmask8 m, __m128h a, __m128h b) {
1131 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_neq_uq
1132 // CHECK: [[CMP:%.*]] = fcmp une <8 x half> %{{.*}}, %{{.*}}
1133 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1134 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_UQ);
1135 }
1136
1137 __mmask8 test_mm_mask_cmp_ph_mask_nlt_us(__mmask8 m, __m128h a, __m128h b) {
1138 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_nlt_us
1139 // CHECK: [[CMP:%.*]] = fcmp uge <8 x half> %{{.*}}, %{{.*}}
1140 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1141 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NLT_US);
1142 }
1143
1144 __mmask8 test_mm_mask_cmp_ph_mask_nle_us(__mmask8 m, __m128h a, __m128h b) {
1145 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_nle_us
1146 // CHECK: [[CMP:%.*]] = fcmp ugt <8 x half> %{{.*}}, %{{.*}}
1147 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1148 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NLE_US);
1149 }
1150
1151 __mmask8 test_mm_mask_cmp_ph_mask_ord_q(__mmask8 m, __m128h a, __m128h b) {
1152 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_ord_q
1153 // CHECK: [[CMP:%.*]] = fcmp ord <8 x half> %{{.*}}, %{{.*}}
1154 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1155 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_ORD_Q);
1156 }
1157
1158 __mmask8 test_mm_mask_cmp_ph_mask_eq_uq(__mmask8 m, __m128h a, __m128h b) {
1159 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_eq_uq
1160 // CHECK: [[CMP:%.*]] = fcmp ueq <8 x half> %{{.*}}, %{{.*}}
1161 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1162 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_EQ_UQ);
1163 }
1164
1165 __mmask8 test_mm_mask_cmp_ph_mask_nge_us(__mmask8 m, __m128h a, __m128h b) {
1166 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_nge_us
1167 // CHECK: [[CMP:%.*]] = fcmp ult <8 x half> %{{.*}}, %{{.*}}
1168 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1169 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NGE_US);
1170 }
1171
1172 __mmask8 test_mm_mask_cmp_ph_mask_ngt_us(__mmask8 m, __m128h a, __m128h b) {
1173 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_ngt_us
1174 // CHECK: [[CMP:%.*]] = fcmp ule <8 x half> %{{.*}}, %{{.*}}
1175 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1176 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NGT_US);
1177 }
1178
1179 __mmask8 test_mm_mask_cmp_ph_mask_false_oq(__mmask8 m, __m128h a, __m128h b) {
1180 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_false_oq
1181 // CHECK: [[CMP:%.*]] = fcmp false <8 x half> %{{.*}}, %{{.*}}
1182 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1183 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OQ);
1184 }
1185
1186 __mmask8 test_mm_mask_cmp_ph_mask_neq_oq(__mmask8 m, __m128h a, __m128h b) {
1187 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_neq_oq
1188 // CHECK: [[CMP:%.*]] = fcmp one <8 x half> %{{.*}}, %{{.*}}
1189 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1190 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OQ);
1191 }
1192
1193 __mmask8 test_mm_mask_cmp_ph_mask_ge_os(__mmask8 m, __m128h a, __m128h b) {
1194 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_ge_os
1195 // CHECK: [[CMP:%.*]] = fcmp oge <8 x half> %{{.*}}, %{{.*}}
1196 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1197 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_GE_OS);
1198 }
1199
1200 __mmask8 test_mm_mask_cmp_ph_mask_gt_os(__mmask8 m, __m128h a, __m128h b) {
1201 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_gt_os
1202 // CHECK: [[CMP:%.*]] = fcmp ogt <8 x half> %{{.*}}, %{{.*}}
1203 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1204 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_GT_OS);
1205 }
1206
1207 __mmask8 test_mm_mask_cmp_ph_mask_true_uq(__mmask8 m, __m128h a, __m128h b) {
1208 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_true_uq
1209 // CHECK: [[CMP:%.*]] = fcmp true <8 x half> %{{.*}}, %{{.*}}
1210 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1211 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_UQ);
1212 }
1213
1214 __mmask8 test_mm_mask_cmp_ph_mask_eq_os(__mmask8 m, __m128h a, __m128h b) {
1215 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_eq_os
1216 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x half> %{{.*}}, %{{.*}}
1217 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1218 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OS);
1219 }
1220
1221 __mmask8 test_mm_mask_cmp_ph_mask_lt_oq(__mmask8 m, __m128h a, __m128h b) {
1222 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_lt_oq
1223 // CHECK: [[CMP:%.*]] = fcmp olt <8 x half> %{{.*}}, %{{.*}}
1224 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1225 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_LT_OQ);
1226 }
1227
1228 __mmask8 test_mm_mask_cmp_ph_mask_le_oq(__mmask8 m, __m128h a, __m128h b) {
1229 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_le_oq
1230 // CHECK: [[CMP:%.*]] = fcmp ole <8 x half> %{{.*}}, %{{.*}}
1231 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1232 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_LE_OQ);
1233 }
1234
1235 __mmask8 test_mm_mask_cmp_ph_mask_unord_s(__mmask8 m, __m128h a, __m128h b) {
1236 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_unord_s
1237 // CHECK: [[CMP:%.*]] = fcmp uno <8 x half> %{{.*}}, %{{.*}}
1238 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1239 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_S);
1240 }
1241
1242 __mmask8 test_mm_mask_cmp_ph_mask_neq_us(__mmask8 m, __m128h a, __m128h b) {
1243 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_neq_us
1244 // CHECK: [[CMP:%.*]] = fcmp une <8 x half> %{{.*}}, %{{.*}}
1245 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1246 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_US);
1247 }
1248
1249 __mmask8 test_mm_mask_cmp_ph_mask_nlt_uq(__mmask8 m, __m128h a, __m128h b) {
1250 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_nlt_uq
1251 // CHECK: [[CMP:%.*]] = fcmp uge <8 x half> %{{.*}}, %{{.*}}
1252 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1253 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NLT_UQ);
1254 }
1255
1256 __mmask8 test_mm_mask_cmp_ph_mask_nle_uq(__mmask8 m, __m128h a, __m128h b) {
1257 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_nle_uq
1258 // CHECK: [[CMP:%.*]] = fcmp ugt <8 x half> %{{.*}}, %{{.*}}
1259 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1260 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NLE_UQ);
1261 }
1262
1263 __mmask8 test_mm_mask_cmp_ph_mask_ord_s(__mmask8 m, __m128h a, __m128h b) {
1264 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_ord_s
1265 // CHECK: [[CMP:%.*]] = fcmp ord <8 x half> %{{.*}}, %{{.*}}
1266 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1267 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_ORD_S);
1268 }
1269
1270 __mmask8 test_mm_mask_cmp_ph_mask_eq_us(__mmask8 m, __m128h a, __m128h b) {
1271 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_eq_us
1272 // CHECK: [[CMP:%.*]] = fcmp ueq <8 x half> %{{.*}}, %{{.*}}
1273 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1274 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_EQ_US);
1275 }
1276
1277 __mmask8 test_mm_mask_cmp_ph_mask_nge_uq(__mmask8 m, __m128h a, __m128h b) {
1278 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_nge_uq
1279 // CHECK: [[CMP:%.*]] = fcmp ult <8 x half> %{{.*}}, %{{.*}}
1280 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1281 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NGE_UQ);
1282 }
1283
1284 __mmask8 test_mm_mask_cmp_ph_mask_ngt_uq(__mmask8 m, __m128h a, __m128h b) {
1285 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_ngt_uq
1286 // CHECK: [[CMP:%.*]] = fcmp ule <8 x half> %{{.*}}, %{{.*}}
1287 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1288 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NGT_UQ);
1289 }
1290
1291 __mmask8 test_mm_mask_cmp_ph_mask_false_os(__mmask8 m, __m128h a, __m128h b) {
1292 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_false_os
1293 // CHECK: [[CMP:%.*]] = fcmp false <8 x half> %{{.*}}, %{{.*}}
1294 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1295 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OS);
1296 }
1297
1298 __mmask8 test_mm_mask_cmp_ph_mask_neq_os(__mmask8 m, __m128h a, __m128h b) {
1299 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_neq_os
1300 // CHECK: [[CMP:%.*]] = fcmp one <8 x half> %{{.*}}, %{{.*}}
1301 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1302 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OS);
1303 }
1304
1305 __mmask8 test_mm_mask_cmp_ph_mask_ge_oq(__mmask8 m, __m128h a, __m128h b) {
1306 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_ge_oq
1307 // CHECK: [[CMP:%.*]] = fcmp oge <8 x half> %{{.*}}, %{{.*}}
1308 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1309 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_GE_OQ);
1310 }
1311
1312 __mmask8 test_mm_mask_cmp_ph_mask_gt_oq(__mmask8 m, __m128h a, __m128h b) {
1313 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_gt_oq
1314 // CHECK: [[CMP:%.*]] = fcmp ogt <8 x half> %{{.*}}, %{{.*}}
1315 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1316 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_GT_OQ);
1317 }
1318
1319 __mmask8 test_mm_mask_cmp_ph_mask_true_us(__mmask8 m, __m128h a, __m128h b) {
1320 // CHECK-LABEL: test_mm_mask_cmp_ph_mask_true_us
1321 // CHECK: [[CMP:%.*]] = fcmp true <8 x half> %{{.*}}, %{{.*}}
1322 // CHECK: and <8 x i1> [[CMP]], {{.*}}
1323 return _mm_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_US);
1324 }
1325
1326 __m256h test_mm256_rcp_ph(__m256h __A) {
1327 // CHECK-LABEL: @test_mm256_rcp_ph
1328 // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.256
1329 return _mm256_rcp_ph(__A);
1330 }
1331
1332 __m256h test_mm256_mask_rcp_ph(__m256h __W, __mmask32 __U, __m256h __A) {
1333 // CHECK-LABEL: @test_mm256_mask_rcp_ph
1334 // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.256
1335 return (__m256h)_mm256_mask_rcp_ph(__W, __U, __A);
1336 }
1337
1338 __m256h test_mm256_maskz_rcp_ph(__mmask32 __U, __m256h __A) {
1339 // CHECK-LABEL: @test_mm256_maskz_rcp_ph
1340 // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.256
1341 return _mm256_maskz_rcp_ph(__U, __A);
1342 }
1343
1344 __m128h test_mm_rcp_ph(__m128h __A) {
1345 // CHECK-LABEL: @test_mm_rcp_ph
1346 // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.128
1347 return _mm_rcp_ph(__A);
1348 }
1349
1350 __m128h test_mm_mask_rcp_ph(__m128h __W, __mmask32 __U, __m128h __A) {
1351 // CHECK-LABEL: @test_mm_mask_rcp_ph
1352 // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.128
1353 return (__m128h)_mm_mask_rcp_ph(__W, __U, __A);
1354 }
1355
1356 __m128h test_mm_maskz_rcp_ph(__mmask32 __U, __m128h __A) {
1357 // CHECK-LABEL: @test_mm_maskz_rcp_ph
1358 // CHECK: @llvm.x86.avx512fp16.mask.rcp.ph.128
1359 return _mm_maskz_rcp_ph(__U, __A);
1360 }
1361
1362 __m256h test_mm256_rsqrt_ph(__m256h __A) {
1363 // CHECK-LABEL: @test_mm256_rsqrt_ph
1364 // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.256
1365 return _mm256_rsqrt_ph(__A);
1366 }
1367
1368 __m256h test_mm256_mask_rsqrt_ph(__m256h __W, __mmask16 __U, __m256h __A) {
1369 // CHECK-LABEL: @test_mm256_mask_rsqrt_ph
1370 // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.256
1371 return (__m256h)_mm256_mask_rsqrt_ph(__W, __U, __A);
1372 }
1373
1374 __m256h test_mm256_maskz_rsqrt_ph(__mmask16 __U, __m256h __A) {
1375 // CHECK-LABEL: @test_mm256_maskz_rsqrt_ph
1376 // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.256
1377 return _mm256_maskz_rsqrt_ph(__U, __A);
1378 }
1379
1380 __m128h test_mm_rsqrt_ph(__m128h __A) {
1381 // CHECK-LABEL: @test_mm_rsqrt_ph
1382 // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.128
1383 return _mm_rsqrt_ph(__A);
1384 }
1385
1386 __m128h test_mm_mask_rsqrt_ph(__m128h __W, __mmask32 __U, __m128h __A) {
1387 // CHECK-LABEL: @test_mm_mask_rsqrt_ph
1388 // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.128
1389 return (__m128h)_mm_mask_rsqrt_ph(__W, __U, __A);
1390 }
1391
1392 __m128h test_mm_maskz_rsqrt_ph(__mmask32 __U, __m128h __A) {
1393 // CHECK-LABEL: @test_mm_maskz_rsqrt_ph
1394 // CHECK: @llvm.x86.avx512fp16.mask.rsqrt.ph.128
1395 return _mm_maskz_rsqrt_ph(__U, __A);
1396 }
1397
1398 __m128h test_mm_getmant_ph(__m128h __A) {
1399 // CHECK-LABEL: @test_mm_getmant_ph
1400 // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.128
1401 return _mm_getmant_ph(__A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1402 }
1403
1404 __m128h test_mm_mask_getmant_ph(__m128h __W, __mmask8 __U, __m128h __A) {
1405 // CHECK-LABEL: @test_mm_mask_getmant_ph
1406 // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.128
1407 return _mm_mask_getmant_ph(__W, __U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1408 }
1409
1410 __m128h test_mm_maskz_getmant_ph(__mmask8 __U, __m128h __A) {
1411 // CHECK-LABEL: @test_mm_maskz_getmant_ph
1412 // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.128
1413 return _mm_maskz_getmant_ph(__U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1414 }
1415
1416 __m256h test_mm256_getmant_ph(__m256h __A) {
1417 // CHECK-LABEL: @test_mm256_getmant_ph
1418 // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.256
1419 return _mm256_getmant_ph(__A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1420 }
1421
1422 __m256h test_mm256_mask_getmant_ph(__m256h __W, __mmask16 __U, __m256h __A) {
1423 // CHECK-LABEL: @test_mm256_mask_getmant_ph
1424 // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.256
1425 return _mm256_mask_getmant_ph(__W, __U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1426 }
1427
1428 __m256h test_mm256_maskz_getmant_ph(__mmask16 __U, __m256h __A) {
1429 // CHECK-LABEL: @test_mm256_maskz_getmant_ph
1430 // CHECK: @llvm.x86.avx512fp16.mask.getmant.ph.256
1431 return _mm256_maskz_getmant_ph(__U, __A, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan);
1432 }
1433
1434 __m128h test_mm_getexp_ph(__m128h __A) {
1435 // CHECK-LABEL: @test_mm_getexp_ph
1436 // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.128
1437 return _mm_getexp_ph(__A);
1438 }
1439
1440 __m128h test_mm_mask_getexp_ph(__m128h __W, __mmask8 __U, __m128h __A) {
1441 // CHECK-LABEL: @test_mm_mask_getexp_ph
1442 // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.128
1443 return _mm_mask_getexp_ph(__W, __U, __A);
1444 }
1445
1446 __m128h test_mm_maskz_getexp_ph(__mmask8 __U, __m128h __A) {
1447 // CHECK-LABEL: @test_mm_maskz_getexp_ph
1448 // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.128
1449 return _mm_maskz_getexp_ph(__U, __A);
1450 }
1451
1452 __m256h test_mm256_getexp_ph(__m256h __A) {
1453 // CHECK-LABEL: @test_mm256_getexp_ph
1454 // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.256
1455 return _mm256_getexp_ph(__A);
1456 }
1457
1458 __m256h test_mm256_mask_getexp_ph(__m256h __W, __mmask16 __U, __m256h __A) {
1459 // CHECK-LABEL: @test_mm256_mask_getexp_ph
1460 // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.256
1461 return _mm256_mask_getexp_ph(__W, __U, __A);
1462 }
1463
1464 __m256h test_mm256_maskz_getexp_ph(__mmask16 __U, __m256h __A) {
1465 // CHECK-LABEL: @test_mm256_maskz_getexp_ph
1466 // CHECK: @llvm.x86.avx512fp16.mask.getexp.ph.256
1467 return _mm256_maskz_getexp_ph(__U, __A);
1468 }
1469
1470 __m128h test_mm_scalef_ph(__m128h __A, __m128h __B) {
1471 // CHECK-LABEL: @test_mm_scalef_ph
1472 // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.128
1473 return _mm_scalef_ph(__A, __B);
1474 }
1475
1476 __m128h test_mm_mask_scalef_ph(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1477 // CHECK-LABEL: @test_mm_mask_scalef_ph
1478 // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.128
1479 return _mm_mask_scalef_ph(__W, __U, __A, __B);
1480 }
1481
1482 __m128h test_mm_maskz_scalef_ph(__mmask8 __U, __m128h __A, __m128h __B) {
1483 // CHECK-LABEL: @test_mm_maskz_scalef_ph
1484 // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.128
1485 return _mm_maskz_scalef_ph(__U, __A, __B);
1486 }
1487
1488 __m256h test_mm256_scalef_ph(__m256h __A, __m256h __B) {
1489 // CHECK-LABEL: @test_mm256_scalef_ph
1490 // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.256
1491 return _mm256_scalef_ph(__A, __B);
1492 }
1493
1494 __m256h test_mm256_mask_scalef_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
1495 // CHECK-LABEL: @test_mm256_mask_scalef_ph
1496 // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.256
1497 return _mm256_mask_scalef_ph(__W, __U, __A, __B);
1498 }
1499
1500 __m256h test_mm256_maskz_scalef_ph(__mmask16 __U, __m256h __A, __m256h __B) {
1501 // CHECK-LABEL: @test_mm256_maskz_scalef_ph
1502 // CHECK: @llvm.x86.avx512fp16.mask.scalef.ph.256
1503 return _mm256_maskz_scalef_ph(__U, __A, __B);
1504 }
1505
1506 __m128h test_mm_roundscale_ph(__m128h __A) {
1507 // CHECK-LABEL: @test_mm_roundscale_ph
1508 // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.128
1509 return _mm_roundscale_ph(__A, 4);
1510 }
1511
1512 __m128h test_mm_mask_roundscale_ph(__m128h __W, __mmask8 __U, __m128h __A) {
1513 // CHECK-LABEL: @test_mm_mask_roundscale_ph
1514 // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.128
1515 return _mm_mask_roundscale_ph(__W, __U, __A, 4);
1516 }
1517
1518 __m128h test_mm_maskz_roundscale_ph(__mmask8 __U, __m128h __A) {
1519 // CHECK-LABEL: @test_mm_maskz_roundscale_ph
1520 // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.128
1521 return _mm_maskz_roundscale_ph(__U, __A, 4);
1522 }
1523
1524 __m256h test_mm256_roundscale_ph(__m256h __A) {
1525 // CHECK-LABEL: @test_mm256_roundscale_ph
1526 // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.256
1527 return _mm256_roundscale_ph(__A, 4);
1528 }
1529
1530 __m256h test_mm256_mask_roundscale_ph(__m256h __W, __mmask16 __U, __m256h __A) {
1531 // CHECK-LABEL: @test_mm256_mask_roundscale_ph
1532 // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.256
1533 return _mm256_mask_roundscale_ph(__W, __U, __A, 4);
1534 }
1535
1536 __m256h test_mm256_maskz_roundscale_ph(__mmask16 __U, __m256h __A) {
1537 // CHECK-LABEL: @test_mm256_maskz_roundscale_ph
1538 // CHECK: @llvm.x86.avx512fp16.mask.rndscale.ph.256
1539 return _mm256_maskz_roundscale_ph(__U, __A, 4);
1540 }
1541
1542 __m128h test_mm_reduce_ph(__m128h __A) {
1543 // CHECK-LABEL: @test_mm_reduce_ph
1544 // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.128
1545 return _mm_reduce_ph(__A, 4);
1546 }
1547
1548 __m128h test_mm_mask_reduce_ph(__m128h __W, __mmask8 __U, __m128h __A) {
1549 // CHECK-LABEL: @test_mm_mask_reduce_ph
1550 // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.128
1551 return _mm_mask_reduce_ph(__W, __U, __A, 4);
1552 }
1553
1554 __m128h test_mm_maskz_reduce_ph(__mmask8 __U, __m128h __A) {
1555 // CHECK-LABEL: @test_mm_maskz_reduce_ph
1556 // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.128
1557 return _mm_maskz_reduce_ph(__U, __A, 4);
1558 }
1559
1560 __m256h test_mm256_reduce_ph(__m256h __A) {
1561 // CHECK-LABEL: @test_mm256_reduce_ph
1562 // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.256
1563 return _mm256_reduce_ph(__A, 4);
1564 }
1565
1566 __m256h test_mm256_mask_reduce_ph(__m256h __W, __mmask16 __U, __m256h __A) {
1567 // CHECK-LABEL: @test_mm256_mask_reduce_ph
1568 // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.256
1569 return _mm256_mask_reduce_ph(__W, __U, __A, 4);
1570 }
1571
1572 __m256h test_mm256_maskz_reduce_ph(__mmask16 __U, __m256h __A) {
1573 // CHECK-LABEL: @test_mm256_maskz_reduce_ph
1574 // CHECK: @llvm.x86.avx512fp16.mask.reduce.ph.256
1575 return _mm256_maskz_reduce_ph(__U, __A, 4);
1576 }
1577 __m128h test_mm_sqrt_ph(__m128h x) {
1578 // CHECK-LABEL: test_mm_sqrt_ph
1579 // CHECK: call <8 x half> @llvm.sqrt.v8f16(<8 x half> {{.*}})
1580 return _mm_sqrt_ph(x);
1581 }
1582
1583 __m256h test_mm256_sqrt_ph(__m256h A) {
1584 // CHECK-LABEL: test_mm256_sqrt_ph
1585 // CHECK: call <16 x half> @llvm.sqrt.v16f16(<16 x half> %{{.*}})
1586 return _mm256_sqrt_ph(A);
1587 }
1588
1589 __m128h test_mm_mask_sqrt_ph(__m128h __W, __mmask8 __U, __m128h __A) {
1590 // CHECK-LABEL: @test_mm_mask_sqrt_ph
1591 // CHECK: @llvm.sqrt.v8f16
1592 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
1593 return _mm_mask_sqrt_ph(__W, __U, __A);
1594 }
1595
1596 __m128h test_mm_maskz_sqrt_ph(__mmask8 __U, __m128h __A) {
1597 // CHECK-LABEL: @test_mm_maskz_sqrt_ph
1598 // CHECK: @llvm.sqrt.v8f16
1599 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
1600 return _mm_maskz_sqrt_ph(__U, __A);
1601 }
1602
1603 __m256h test_mm256_mask_sqrt_ph(__m256h __W, __mmask16 __U, __m256h __A) {
1604 // CHECK-LABEL: @test_mm256_mask_sqrt_ph
1605 // CHECK: @llvm.sqrt.v16f16
1606 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1607 return _mm256_mask_sqrt_ph(__W, __U, __A);
1608 }
1609
1610 __m256h test_mm256_maskz_sqrt_ph(__mmask16 __U, __m256h __A) {
1611 // CHECK-LABEL: @test_mm256_maskz_sqrt_ph
1612 // CHECK: @llvm.sqrt.v16f16
1613 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
1614 return _mm256_maskz_sqrt_ph(__U, __A);
1615 }
1616 __mmask8 test_mm_mask_fpclass_ph_mask(__mmask8 __U, __m128h __A) {
1617 // CHECK-LABEL: @test_mm_mask_fpclass_ph_mask
1618 // CHECK: @llvm.x86.avx512fp16.fpclass.ph.128
1619 return _mm_mask_fpclass_ph_mask(__U, __A, 2);
1620 }
1621
1622 __mmask8 test_mm_fpclass_ph_mask(__m128h __A) {
1623 // CHECK-LABEL: @test_mm_fpclass_ph_mask
1624 // CHECK: @llvm.x86.avx512fp16.fpclass.ph.128
1625 return _mm_fpclass_ph_mask(__A, 2);
1626 }
1627
1628 __mmask16 test_mm256_mask_fpclass_ph_mask(__mmask16 __U, __m256h __A) {
1629 // CHECK-LABEL: @test_mm256_mask_fpclass_ph_mask
1630 // CHECK: @llvm.x86.avx512fp16.fpclass.ph.256
1631 return _mm256_mask_fpclass_ph_mask(__U, __A, 2);
1632 }
1633
1634 __mmask16 test_mm256_fpclass_ph_mask(__m256h __A) {
1635 // CHECK-LABEL: @test_mm256_fpclass_ph_mask
1636 // CHECK: @llvm.x86.avx512fp16.fpclass.ph.256
1637 return _mm256_fpclass_ph_mask(__A, 2);
1638 }
1639
1640 __m128h test_mm_cvtpd_ph(__m128d A) {
1641 // CHECK-LABEL: test_mm_cvtpd_ph
1642 // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.128
1643 return _mm_cvtpd_ph(A);
1644 }
1645
1646 __m128h test_mm_mask_cvtpd_ph(__m128h A, __mmask8 B, __m128d C) {
1647 // CHECK-LABEL: test_mm_mask_cvtpd_ph
1648 // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.128
1649 return _mm_mask_cvtpd_ph(A, B, C);
1650 }
1651
1652 __m128h test_mm_maskz_cvtpd_ph(__mmask8 A, __m128d B) {
1653 // CHECK-LABEL: test_mm_maskz_cvtpd_ph
1654 // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.128
1655 return _mm_maskz_cvtpd_ph(A, B);
1656 }
1657
1658 __m128h test_mm256_cvtpd_ph(__m256d A) {
1659 // CHECK-LABEL: test_mm256_cvtpd_ph
1660 // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.256
1661 return _mm256_cvtpd_ph(A);
1662 }
1663
1664 __m128h test_mm256_mask_cvtpd_ph(__m128h A, __mmask8 B, __m256d C) {
1665 // CHECK-LABEL: test_mm256_mask_cvtpd_ph
1666 // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.256
1667 return _mm256_mask_cvtpd_ph(A, B, C);
1668 }
1669
1670 __m128h test_mm256_maskz_cvtpd_ph(__mmask8 A, __m256d B) {
1671 // CHECK-LABEL: test_mm256_maskz_cvtpd_ph
1672 // CHECK: @llvm.x86.avx512fp16.mask.vcvtpd2ph.256
1673 return _mm256_maskz_cvtpd_ph(A, B);
1674 }
1675
1676 __m128d test_mm_cvtph_pd(__m128h A) {
1677 // CHECK-LABEL: test_mm_cvtph_pd
1678 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.128
1679 return _mm_cvtph_pd(A);
1680 }
1681
1682 __m128d test_mm_mask_cvtph_pd(__m128d A, __mmask8 B, __m128h C) {
1683 // CHECK-LABEL: test_mm_mask_cvtph_pd
1684 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.128
1685 return _mm_mask_cvtph_pd(A, B, C);
1686 }
1687
1688 __m128d test_mm_maskz_cvtph_pd(__mmask8 A, __m128h B) {
1689 // CHECK-LABEL: test_mm_maskz_cvtph_pd
1690 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.128
1691 return _mm_maskz_cvtph_pd(A, B);
1692 }
1693
1694 __m256d test_mm256_cvtph_pd(__m128h A) {
1695 // CHECK-LABEL: test_mm256_cvtph_pd
1696 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.256
1697 return _mm256_cvtph_pd(A);
1698 }
1699
1700 __m256d test_mm256_mask_cvtph_pd(__m256d A, __mmask8 B, __m128h C) {
1701 // CHECK-LABEL: test_mm256_mask_cvtph_pd
1702 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.256
1703 return _mm256_mask_cvtph_pd(A, B, C);
1704 }
1705
1706 __m256d test_mm256_maskz_cvtph_pd(__mmask8 A, __m128h B) {
1707 // CHECK-LABEL: test_mm256_maskz_cvtph_pd
1708 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2pd.256
1709 return _mm256_maskz_cvtph_pd(A, B);
1710 }
1711
1712 __m128i test_mm_cvtph_epi16(__m128h A) {
1713 // CHECK-LABEL: test_mm_cvtph_epi16
1714 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.128
1715 return _mm_cvtph_epi16(A);
1716 }
1717
1718 __m128i test_mm_mask_cvtph_epi16(__m128i A, __mmask8 B, __m128h C) {
1719 // CHECK-LABEL: test_mm_mask_cvtph_epi16
1720 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.128
1721 return _mm_mask_cvtph_epi16(A, B, C);
1722 }
1723
1724 __m128i test_mm_maskz_cvtph_epi16(__mmask8 A, __m128h B) {
1725 // CHECK-LABEL: test_mm_maskz_cvtph_epi16
1726 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.128
1727 return _mm_maskz_cvtph_epi16(A, B);
1728 }
1729
1730 __m256i test_mm256_cvtph_epi16(__m256h A) {
1731 // CHECK-LABEL: test_mm256_cvtph_epi16
1732 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.256
1733 return _mm256_cvtph_epi16(A);
1734 }
1735
1736 __m256i test_mm256_mask_cvtph_epi16(__m256i A, __mmask16 B, __m256h C) {
1737 // CHECK-LABEL: test_mm256_mask_cvtph_epi16
1738 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.256
1739 return _mm256_mask_cvtph_epi16(A, B, C);
1740 }
1741
1742 __m256i test_mm256_maskz_cvtph_epi16(__mmask16 A, __m256h B) {
1743 // CHECK-LABEL: test_mm256_maskz_cvtph_epi16
1744 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2w.256
1745 return _mm256_maskz_cvtph_epi16(A, B);
1746 }
1747
1748 __m128i test_mm_cvttph_epi16(__m128h A) {
1749 // CHECK-LABEL: test_mm_cvttph_epi16
1750 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.128
1751 return _mm_cvttph_epi16(A);
1752 }
1753
1754 __m128i test_mm_mask_cvttph_epi16(__m128i A, __mmask8 B, __m128h C) {
1755 // CHECK-LABEL: test_mm_mask_cvttph_epi16
1756 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.128
1757 return _mm_mask_cvttph_epi16(A, B, C);
1758 }
1759
1760 __m128i test_mm_maskz_cvttph_epi16(__mmask8 A, __m128h B) {
1761 // CHECK-LABEL: test_mm_maskz_cvttph_epi16
1762 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.128
1763 return _mm_maskz_cvttph_epi16(A, B);
1764 }
1765
1766 __m256i test_mm256_cvttph_epi16(__m256h A) {
1767 // CHECK-LABEL: test_mm256_cvttph_epi16
1768 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.256
1769 return _mm256_cvttph_epi16(A);
1770 }
1771
1772 __m256i test_mm256_mask_cvttph_epi16(__m256i A, __mmask16 B, __m256h C) {
1773 // CHECK-LABEL: test_mm256_mask_cvttph_epi16
1774 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.256
1775 return _mm256_mask_cvttph_epi16(A, B, C);
1776 }
1777
1778 __m256i test_mm256_maskz_cvttph_epi16(__mmask16 A, __m256h B) {
1779 // CHECK-LABEL: test_mm256_maskz_cvttph_epi16
1780 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2w.256
1781 return _mm256_maskz_cvttph_epi16(A, B);
1782 }
1783
1784 __m128h test_mm_cvtepi16_ph(__m128i A) {
1785 // CHECK-LABEL: test_mm_cvtepi16_ph
1786 // CHECK: %{{.*}} = sitofp <8 x i16> %{{.*}} to <8 x half>
1787 return _mm_cvtepi16_ph(A);
1788 }
1789
1790 __m128h test_mm_mask_cvtepi16_ph(__m128h A, __mmask8 B, __m128i C) {
1791 // CHECK-LABEL: test_mm_mask_cvtepi16_ph
1792 // CHECK: %{{.*}} = sitofp <8 x i16> %{{.*}} to <8 x half>
1793 return _mm_mask_cvtepi16_ph(A, B, C);
1794 }
1795
1796 __m128h test_mm_maskz_cvtepi16_ph(__mmask8 A, __m128i B) {
1797 // CHECK-LABEL: test_mm_maskz_cvtepi16_ph
1798 // CHECK: %{{.*}} = sitofp <8 x i16> %{{.*}} to <8 x half>
1799 return _mm_maskz_cvtepi16_ph(A, B);
1800 }
1801
1802 __m256h test_mm256_cvtepi16_ph(__m256i A) {
1803 // CHECK-LABEL: test_mm256_cvtepi16_ph
1804 // CHECK: %{{.*}} = sitofp <16 x i16> %{{.*}} to <16 x half>
1805 return _mm256_cvtepi16_ph(A);
1806 }
1807
1808 __m256h test_mm256_mask_cvtepi16_ph(__m256h A, __mmask16 B, __m256i C) {
1809 // CHECK-LABEL: test_mm256_mask_cvtepi16_ph
1810 // CHECK: %{{.*}} = sitofp <16 x i16> %{{.*}} to <16 x half>
1811 return _mm256_mask_cvtepi16_ph(A, B, C);
1812 }
1813
1814 __m256h test_mm256_maskz_cvtepi16_ph(__mmask16 A, __m256i B) {
1815 // CHECK-LABEL: test_mm256_maskz_cvtepi16_ph
1816 // CHECK: %{{.*}} = sitofp <16 x i16> %{{.*}} to <16 x half>
1817 return _mm256_maskz_cvtepi16_ph(A, B);
1818 }
1819
1820 __m128i test_mm_cvtph_epu16(__m128h A) {
1821 // CHECK-LABEL: test_mm_cvtph_epu16
1822 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.128
1823 return _mm_cvtph_epu16(A);
1824 }
1825
1826 __m128i test_mm_mask_cvtph_epu16(__m128i A, __mmask8 B, __m128h C) {
1827 // CHECK-LABEL: test_mm_mask_cvtph_epu16
1828 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.128
1829 return _mm_mask_cvtph_epu16(A, B, C);
1830 }
1831
1832 __m128i test_mm_maskz_cvtph_epu16(__mmask8 A, __m128h B) {
1833 // CHECK-LABEL: test_mm_maskz_cvtph_epu16
1834 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.128
1835 return _mm_maskz_cvtph_epu16(A, B);
1836 }
1837
1838 __m256i test_mm256_cvtph_epu16(__m256h A) {
1839 // CHECK-LABEL: test_mm256_cvtph_epu16
1840 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.256
1841 return _mm256_cvtph_epu16(A);
1842 }
1843
1844 __m256i test_mm256_mask_cvtph_epu16(__m256i A, __mmask16 B, __m256h C) {
1845 // CHECK-LABEL: test_mm256_mask_cvtph_epu16
1846 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.256
1847 return _mm256_mask_cvtph_epu16(A, B, C);
1848 }
1849
1850 __m256i test_mm256_maskz_cvtph_epu16(__mmask16 A, __m256h B) {
1851 // CHECK-LABEL: test_mm256_maskz_cvtph_epu16
1852 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uw.256
1853 return _mm256_maskz_cvtph_epu16(A, B);
1854 }
1855
1856 __m128i test_mm_cvttph_epu16(__m128h A) {
1857 // CHECK-LABEL: test_mm_cvttph_epu16
1858 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.128
1859 return _mm_cvttph_epu16(A);
1860 }
1861
1862 __m128i test_mm_mask_cvttph_epu16(__m128i A, __mmask8 B, __m128h C) {
1863 // CHECK-LABEL: test_mm_mask_cvttph_epu16
1864 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.128
1865 return _mm_mask_cvttph_epu16(A, B, C);
1866 }
1867
1868 __m128i test_mm_maskz_cvttph_epu16(__mmask8 A, __m128h B) {
1869 // CHECK-LABEL: test_mm_maskz_cvttph_epu16
1870 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.128
1871 return _mm_maskz_cvttph_epu16(A, B);
1872 }
1873
1874 __m256i test_mm256_cvttph_epu16(__m256h A) {
1875 // CHECK-LABEL: test_mm256_cvttph_epu16
1876 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.256
1877 return _mm256_cvttph_epu16(A);
1878 }
1879
1880 __m256i test_mm256_mask_cvttph_epu16(__m256i A, __mmask16 B, __m256h C) {
1881 // CHECK-LABEL: test_mm256_mask_cvttph_epu16
1882 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.256
1883 return _mm256_mask_cvttph_epu16(A, B, C);
1884 }
1885
1886 __m256i test_mm256_maskz_cvttph_epu16(__mmask16 A, __m256h B) {
1887 // CHECK-LABEL: test_mm256_maskz_cvttph_epu16
1888 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uw.256
1889 return _mm256_maskz_cvttph_epu16(A, B);
1890 }
1891
1892 __m128h test_mm_cvtepu16_ph(__m128i A) {
1893 // CHECK-LABEL: test_mm_cvtepu16_ph
1894 // CHECK: %{{.*}} = uitofp <8 x i16> %{{.*}} to <8 x half>
1895 return _mm_cvtepu16_ph(A);
1896 }
1897
1898 __m128h test_mm_mask_cvtepu16_ph(__m128h A, __mmask8 B, __m128i C) {
1899 // CHECK-LABEL: test_mm_mask_cvtepu16_ph
1900 // CHECK: %{{.*}} = uitofp <8 x i16> %{{.*}} to <8 x half>
1901 return _mm_mask_cvtepu16_ph(A, B, C);
1902 }
1903
1904 __m128h test_mm_maskz_cvtepu16_ph(__mmask8 A, __m128i B) {
1905 // CHECK-LABEL: test_mm_maskz_cvtepu16_ph
1906 // CHECK: %{{.*}} = uitofp <8 x i16> %{{.*}} to <8 x half>
1907 return _mm_maskz_cvtepu16_ph(A, B);
1908 }
1909
1910 __m256h test_mm256_cvtepu16_ph(__m256i A) {
1911 // CHECK-LABEL: test_mm256_cvtepu16_ph
1912 // CHECK: %{{.*}} = uitofp <16 x i16> %{{.*}} to <16 x half>
1913 return _mm256_cvtepu16_ph(A);
1914 }
1915
1916 __m256h test_mm256_mask_cvtepu16_ph(__m256h A, __mmask16 B, __m256i C) {
1917 // CHECK-LABEL: test_mm256_mask_cvtepu16_ph
1918 // CHECK: %{{.*}} = uitofp <16 x i16> %{{.*}} to <16 x half>
1919 return _mm256_mask_cvtepu16_ph(A, B, C);
1920 }
1921
1922 __m256h test_mm256_maskz_cvtepu16_ph(__mmask16 A, __m256i B) {
1923 // CHECK-LABEL: test_mm256_maskz_cvtepu16_ph
1924 // CHECK: %{{.*}} = uitofp <16 x i16> %{{.*}} to <16 x half>
1925 return _mm256_maskz_cvtepu16_ph(A, B);
1926 }
1927
1928 __m128i test_mm_cvtph_epi32(__m128h A) {
1929 // CHECK-LABEL: test_mm_cvtph_epi32
1930 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.128
1931 return _mm_cvtph_epi32(A);
1932 }
1933
1934 __m128i test_mm_mask_cvtph_epi32(__m128i A, __mmask8 B, __m128h C) {
1935 // CHECK-LABEL: test_mm_mask_cvtph_epi32
1936 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.128
1937 return _mm_mask_cvtph_epi32(A, B, C);
1938 }
1939
1940 __m128i test_mm_maskz_cvtph_epi32(__mmask8 A, __m128h B) {
1941 // CHECK-LABEL: test_mm_maskz_cvtph_epi32
1942 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.128
1943 return _mm_maskz_cvtph_epi32(A, B);
1944 }
1945
1946 __m256i test_mm256_cvtph_epi32(__m128h A) {
1947 // CHECK-LABEL: test_mm256_cvtph_epi32
1948 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.256
1949 return _mm256_cvtph_epi32(A);
1950 }
1951
1952 __m256i test_mm256_mask_cvtph_epi32(__m256i A, __mmask8 B, __m128h C) {
1953 // CHECK-LABEL: test_mm256_mask_cvtph_epi32
1954 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.256
1955 return _mm256_mask_cvtph_epi32(A, B, C);
1956 }
1957
1958 __m256i test_mm256_maskz_cvtph_epi32(__mmask8 A, __m128h B) {
1959 // CHECK-LABEL: test_mm256_maskz_cvtph_epi32
1960 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2dq.256
1961 return _mm256_maskz_cvtph_epi32(A, B);
1962 }
1963
1964 __m128i test_mm_cvtph_epu32(__m128h A) {
1965 // CHECK-LABEL: test_mm_cvtph_epu32
1966 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.128
1967 return _mm_cvtph_epu32(A);
1968 }
1969
1970 __m128i test_mm_mask_cvtph_epu32(__m128i A, __mmask8 B, __m128h C) {
1971 // CHECK-LABEL: test_mm_mask_cvtph_epu32
1972 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.128
1973 return _mm_mask_cvtph_epu32(A, B, C);
1974 }
1975
1976 __m128i test_mm_maskz_cvtph_epu32(__mmask8 A, __m128h B) {
1977 // CHECK-LABEL: test_mm_maskz_cvtph_epu32
1978 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.128
1979 return _mm_maskz_cvtph_epu32(A, B);
1980 }
1981
1982 __m256i test_mm256_cvtph_epu32(__m128h A) {
1983 // CHECK-LABEL: test_mm256_cvtph_epu32
1984 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.256
1985 return _mm256_cvtph_epu32(A);
1986 }
1987
1988 __m256i test_mm256_mask_cvtph_epu32(__m256i A, __mmask8 B, __m128h C) {
1989 // CHECK-LABEL: test_mm256_mask_cvtph_epu32
1990 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.256
1991 return _mm256_mask_cvtph_epu32(A, B, C);
1992 }
1993
1994 __m256i test_mm256_maskz_cvtph_epu32(__mmask8 A, __m128h B) {
1995 // CHECK-LABEL: test_mm256_maskz_cvtph_epu32
1996 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2udq.256
1997 return _mm256_maskz_cvtph_epu32(A, B);
1998 }
1999
2000 __m128h test_mm_cvtepi32_ph(__m128i A) {
2001 // CHECK-LABEL: test_mm_cvtepi32_ph
2002 // CHECK: @llvm.x86.avx512fp16.mask.vcvtdq2ph.128
2003 return _mm_cvtepi32_ph(A);
2004 }
2005
2006 __m128h test_mm_mask_cvtepi32_ph(__m128h A, __mmask8 B, __m128i C) {
2007 // CHECK-LABEL: test_mm_mask_cvtepi32_ph
2008 // CHECK: @llvm.x86.avx512fp16.mask.vcvtdq2ph.128
2009 return _mm_mask_cvtepi32_ph(A, B, C);
2010 }
2011
2012 __m128h test_mm_maskz_cvtepi32_ph(__mmask8 A, __m128i B) {
2013 // CHECK-LABEL: test_mm_maskz_cvtepi32_ph
2014 // CHECK: @llvm.x86.avx512fp16.mask.vcvtdq2ph.128
2015 return _mm_maskz_cvtepi32_ph(A, B);
2016 }
2017
2018 __m128h test_mm256_cvtepi32_ph(__m256i A) {
2019 // CHECK-LABEL: test_mm256_cvtepi32_ph
2020 // CHECK: %{{.*}} = sitofp <8 x i32> %{{.*}} to <8 x half>
2021 return _mm256_cvtepi32_ph(A);
2022 }
2023
2024 __m128h test_mm256_mask_cvtepi32_ph(__m128h A, __mmask8 B, __m256i C) {
2025 // CHECK-LABEL: test_mm256_mask_cvtepi32_ph
2026 // CHECK: %{{.*}} = sitofp <8 x i32> %{{.*}} to <8 x half>
2027 return _mm256_mask_cvtepi32_ph(A, B, C);
2028 }
2029
2030 __m128h test_mm256_maskz_cvtepi32_ph(__mmask8 A, __m256i B) {
2031 // CHECK-LABEL: test_mm256_maskz_cvtepi32_ph
2032 // CHECK: %{{.*}} = sitofp <8 x i32> %{{.*}} to <8 x half>
2033 return _mm256_maskz_cvtepi32_ph(A, B);
2034 }
2035
2036 __m128h test_mm_cvtepu32_ph(__m128i A) {
2037 // CHECK-LABEL: test_mm_cvtepu32_ph
2038 // CHECK: @llvm.x86.avx512fp16.mask.vcvtudq2ph.128
2039 return _mm_cvtepu32_ph(A);
2040 }
2041
2042 __m128h test_mm_mask_cvtepu32_ph(__m128h A, __mmask8 B, __m128i C) {
2043 // CHECK-LABEL: test_mm_mask_cvtepu32_ph
2044 // CHECK: @llvm.x86.avx512fp16.mask.vcvtudq2ph.128
2045 return _mm_mask_cvtepu32_ph(A, B, C);
2046 }
2047
2048 __m128h test_mm_maskz_cvtepu32_ph(__mmask8 A, __m128i B) {
2049 // CHECK-LABEL: test_mm_maskz_cvtepu32_ph
2050 // CHECK: @llvm.x86.avx512fp16.mask.vcvtudq2ph.128
2051 return _mm_maskz_cvtepu32_ph(A, B);
2052 }
2053
2054 __m128h test_mm256_cvtepu32_ph(__m256i A) {
2055 // CHECK-LABEL: test_mm256_cvtepu32_ph
2056 // CHECK: %{{.*}} = uitofp <8 x i32> %{{.*}} to <8 x half>
2057 return _mm256_cvtepu32_ph(A);
2058 }
2059
2060 __m128h test_mm256_mask_cvtepu32_ph(__m128h A, __mmask8 B, __m256i C) {
2061 // CHECK-LABEL: test_mm256_mask_cvtepu32_ph
2062 // CHECK: %{{.*}} = uitofp <8 x i32> %{{.*}} to <8 x half>
2063 return _mm256_mask_cvtepu32_ph(A, B, C);
2064 }
2065
2066 __m128h test_mm256_maskz_cvtepu32_ph(__mmask8 A, __m256i B) {
2067 // CHECK-LABEL: test_mm256_maskz_cvtepu32_ph
2068 // CHECK: %{{.*}} = uitofp <8 x i32> %{{.*}} to <8 x half>
2069 return _mm256_maskz_cvtepu32_ph(A, B);
2070 }
2071
2072 __m128i test_mm_cvttph_epi32(__m128h A) {
2073 // CHECK-LABEL: test_mm_cvttph_epi32
2074 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.128
2075 return _mm_cvttph_epi32(A);
2076 }
2077
2078 __m128i test_mm_mask_cvttph_epi32(__m128i A, __mmask8 B, __m128h C) {
2079 // CHECK-LABEL: test_mm_mask_cvttph_epi32
2080 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.128
2081 return _mm_mask_cvttph_epi32(A, B, C);
2082 }
2083
2084 __m128i test_mm_maskz_cvttph_epi32(__mmask8 A, __m128h B) {
2085 // CHECK-LABEL: test_mm_maskz_cvttph_epi32
2086 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.128
2087 return _mm_maskz_cvttph_epi32(A, B);
2088 }
2089
2090 __m256i test_mm256_cvttph_epi32(__m128h A) {
2091 // CHECK-LABEL: test_mm256_cvttph_epi32
2092 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.256
2093 return _mm256_cvttph_epi32(A);
2094 }
2095
2096 __m256i test_mm256_mask_cvttph_epi32(__m256i A, __mmask8 B, __m128h C) {
2097 // CHECK-LABEL: test_mm256_mask_cvttph_epi32
2098 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.256
2099 return _mm256_mask_cvttph_epi32(A, B, C);
2100 }
2101
2102 __m256i test_mm256_maskz_cvttph_epi32(__mmask8 A, __m128h B) {
2103 // CHECK-LABEL: test_mm256_maskz_cvttph_epi32
2104 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2dq.256
2105 return _mm256_maskz_cvttph_epi32(A, B);
2106 }
2107
2108 __m128i test_mm_cvttph_epu32(__m128h A) {
2109 // CHECK-LABEL: test_mm_cvttph_epu32
2110 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.128
2111 return _mm_cvttph_epu32(A);
2112 }
2113
2114 __m128i test_mm_mask_cvttph_epu32(__m128i A, __mmask8 B, __m128h C) {
2115 // CHECK-LABEL: test_mm_mask_cvttph_epu32
2116 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.128
2117 return _mm_mask_cvttph_epu32(A, B, C);
2118 }
2119
2120 __m128i test_mm_maskz_cvttph_epu32(__mmask8 A, __m128h B) {
2121 // CHECK-LABEL: test_mm_maskz_cvttph_epu32
2122 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.128
2123 return _mm_maskz_cvttph_epu32(A, B);
2124 }
2125
2126 __m256i test_mm256_cvttph_epu32(__m128h A) {
2127 // CHECK-LABEL: test_mm256_cvttph_epu32
2128 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.256
2129 return _mm256_cvttph_epu32(A);
2130 }
2131
2132 __m256i test_mm256_mask_cvttph_epu32(__m256i A, __mmask8 B, __m128h C) {
2133 // CHECK-LABEL: test_mm256_mask_cvttph_epu32
2134 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.256
2135 return _mm256_mask_cvttph_epu32(A, B, C);
2136 }
2137
2138 __m256i test_mm256_maskz_cvttph_epu32(__mmask8 A, __m128h B) {
2139 // CHECK-LABEL: test_mm256_maskz_cvttph_epu32
2140 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2udq.256
2141 return _mm256_maskz_cvttph_epu32(A, B);
2142 }
2143
2144 __m128h test_mm_cvtepi64_ph(__m128i A) {
2145 // CHECK-LABEL: test_mm_cvtepi64_ph
2146 // CHECK: @llvm.x86.avx512fp16.mask.vcvtqq2ph.128
2147 return _mm_cvtepi64_ph(A);
2148 }
2149
2150 __m128h test_mm_mask_cvtepi64_ph(__m128h A, __mmask8 B, __m128i C) {
2151 // CHECK-LABEL: test_mm_mask_cvtepi64_ph
2152 // CHECK: @llvm.x86.avx512fp16.mask.vcvtqq2ph.128
2153 return _mm_mask_cvtepi64_ph(A, B, C);
2154 }
2155
2156 __m128h test_mm_maskz_cvtepi64_ph(__mmask8 A, __m128i B) {
2157 // CHECK-LABEL: test_mm_maskz_cvtepi64_ph
2158 // CHECK: @llvm.x86.avx512fp16.mask.vcvtqq2ph.128
2159 return _mm_maskz_cvtepi64_ph(A, B);
2160 }
2161
2162 __m128h test_mm256_cvtepi64_ph(__m256i A) {
2163 // CHECK-LABEL: test_mm256_cvtepi64_ph
2164 // CHECK: @llvm.x86.avx512fp16.mask.vcvtqq2ph.256
2165 return _mm256_cvtepi64_ph(A);
2166 }
2167
2168 __m128h test_mm256_mask_cvtepi64_ph(__m128h A, __mmask8 B, __m256i C) {
2169 // CHECK-LABEL: test_mm256_mask_cvtepi64_ph
2170 // CHECK: @llvm.x86.avx512fp16.mask.vcvtqq2ph.256
2171 return _mm256_mask_cvtepi64_ph(A, B, C);
2172 }
2173
2174 __m128h test_mm256_maskz_cvtepi64_ph(__mmask8 A, __m256i B) {
2175 // CHECK-LABEL: test_mm256_maskz_cvtepi64_ph
2176 // CHECK: @llvm.x86.avx512fp16.mask.vcvtqq2ph.256
2177 return _mm256_maskz_cvtepi64_ph(A, B);
2178 }
2179
2180 __m128i test_mm_cvtph_epi64(__m128h A) {
2181 // CHECK-LABEL: test_mm_cvtph_epi64
2182 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.128
2183 return _mm_cvtph_epi64(A);
2184 }
2185
2186 __m128i test_mm_mask_cvtph_epi64(__m128i A, __mmask8 B, __m128h C) {
2187 // CHECK-LABEL: test_mm_mask_cvtph_epi64
2188 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.128
2189 return _mm_mask_cvtph_epi64(A, B, C);
2190 }
2191
2192 __m128i test_mm_maskz_cvtph_epi64(__mmask8 A, __m128h B) {
2193 // CHECK-LABEL: test_mm_maskz_cvtph_epi64
2194 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.128
2195 return _mm_maskz_cvtph_epi64(A, B);
2196 }
2197
2198 __m256i test_mm256_cvtph_epi64(__m128h A) {
2199 // CHECK-LABEL: test_mm256_cvtph_epi64
2200 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.256
2201 return _mm256_cvtph_epi64(A);
2202 }
2203
2204 __m256i test_mm256_mask_cvtph_epi64(__m256i A, __mmask8 B, __m128h C) {
2205 // CHECK-LABEL: test_mm256_mask_cvtph_epi64
2206 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.256
2207 return _mm256_mask_cvtph_epi64(A, B, C);
2208 }
2209
2210 __m256i test_mm256_maskz_cvtph_epi64(__mmask8 A, __m128h B) {
2211 // CHECK-LABEL: test_mm256_maskz_cvtph_epi64
2212 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2qq.256
2213 return _mm256_maskz_cvtph_epi64(A, B);
2214 }
2215
2216 __m128h test_mm_cvtepu64_ph(__m128i A) {
2217 // CHECK-LABEL: test_mm_cvtepu64_ph
2218 // CHECK: @llvm.x86.avx512fp16.mask.vcvtuqq2ph.128
2219 return _mm_cvtepu64_ph(A);
2220 }
2221
2222 __m128h test_mm_mask_cvtepu64_ph(__m128h A, __mmask8 B, __m128i C) {
2223 // CHECK-LABEL: test_mm_mask_cvtepu64_ph
2224 // CHECK: @llvm.x86.avx512fp16.mask.vcvtuqq2ph.128
2225 return _mm_mask_cvtepu64_ph(A, B, C);
2226 }
2227
2228 __m128h test_mm_maskz_cvtepu64_ph(__mmask8 A, __m128i B) {
2229 // CHECK-LABEL: test_mm_maskz_cvtepu64_ph
2230 // CHECK: @llvm.x86.avx512fp16.mask.vcvtuqq2ph.128
2231 return _mm_maskz_cvtepu64_ph(A, B);
2232 }
2233
2234 __m128h test_mm256_cvtepu64_ph(__m256i A) {
2235 // CHECK-LABEL: test_mm256_cvtepu64_ph
2236 // CHECK: @llvm.x86.avx512fp16.mask.vcvtuqq2ph.256
2237 return _mm256_cvtepu64_ph(A);
2238 }
2239
2240 __m128h test_mm256_mask_cvtepu64_ph(__m128h A, __mmask8 B, __m256i C) {
2241 // CHECK-LABEL: test_mm256_mask_cvtepu64_ph
2242 // CHECK: @llvm.x86.avx512fp16.mask.vcvtuqq2ph.256
2243 return _mm256_mask_cvtepu64_ph(A, B, C);
2244 }
2245
2246 __m128h test_mm256_maskz_cvtepu64_ph(__mmask8 A, __m256i B) {
2247 // CHECK-LABEL: test_mm256_maskz_cvtepu64_ph
2248 // CHECK: @llvm.x86.avx512fp16.mask.vcvtuqq2ph.256
2249 return _mm256_maskz_cvtepu64_ph(A, B);
2250 }
2251
2252 __m128i test_mm_cvtph_epu64(__m128h A) {
2253 // CHECK-LABEL: test_mm_cvtph_epu64
2254 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.128
2255 return _mm_cvtph_epu64(A);
2256 }
2257
2258 __m128i test_mm_mask_cvtph_epu64(__m128i A, __mmask8 B, __m128h C) {
2259 // CHECK-LABEL: test_mm_mask_cvtph_epu64
2260 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.128
2261 return _mm_mask_cvtph_epu64(A, B, C);
2262 }
2263
2264 __m128i test_mm_maskz_cvtph_epu64(__mmask8 A, __m128h B) {
2265 // CHECK-LABEL: test_mm_maskz_cvtph_epu64
2266 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.128
2267 return _mm_maskz_cvtph_epu64(A, B);
2268 }
2269
2270 __m256i test_mm256_cvtph_epu64(__m128h A) {
2271 // CHECK-LABEL: test_mm256_cvtph_epu64
2272 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.256
2273 return _mm256_cvtph_epu64(A);
2274 }
2275
2276 __m256i test_mm256_mask_cvtph_epu64(__m256i A, __mmask8 B, __m128h C) {
2277 // CHECK-LABEL: test_mm256_mask_cvtph_epu64
2278 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.256
2279 return _mm256_mask_cvtph_epu64(A, B, C);
2280 }
2281
2282 __m256i test_mm256_maskz_cvtph_epu64(__mmask8 A, __m128h B) {
2283 // CHECK-LABEL: test_mm256_maskz_cvtph_epu64
2284 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2uqq.256
2285 return _mm256_maskz_cvtph_epu64(A, B);
2286 }
2287
2288 __m128i test_mm_cvttph_epi64(__m128h A) {
2289 // CHECK-LABEL: test_mm_cvttph_epi64
2290 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.128
2291 return _mm_cvttph_epi64(A);
2292 }
2293
2294 __m128i test_mm_mask_cvttph_epi64(__m128i A, __mmask8 B, __m128h C) {
2295 // CHECK-LABEL: test_mm_mask_cvttph_epi64
2296 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.128
2297 return _mm_mask_cvttph_epi64(A, B, C);
2298 }
2299
2300 __m128i test_mm_maskz_cvttph_epi64(__mmask8 A, __m128h B) {
2301 // CHECK-LABEL: test_mm_maskz_cvttph_epi64
2302 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.128
2303 return _mm_maskz_cvttph_epi64(A, B);
2304 }
2305
2306 __m256i test_mm256_cvttph_epi64(__m128h A) {
2307 // CHECK-LABEL: test_mm256_cvttph_epi64
2308 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.256
2309 return _mm256_cvttph_epi64(A);
2310 }
2311
2312 __m256i test_mm256_mask_cvttph_epi64(__m256i A, __mmask8 B, __m128h C) {
2313 // CHECK-LABEL: test_mm256_mask_cvttph_epi64
2314 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.256
2315 return _mm256_mask_cvttph_epi64(A, B, C);
2316 }
2317
2318 __m256i test_mm256_maskz_cvttph_epi64(__mmask8 A, __m128h B) {
2319 // CHECK-LABEL: test_mm256_maskz_cvttph_epi64
2320 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2qq.256
2321 return _mm256_maskz_cvttph_epi64(A, B);
2322 }
2323
2324 __m128i test_mm_cvttph_epu64(__m128h A) {
2325 // CHECK-LABEL: test_mm_cvttph_epu64
2326 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.128
2327 return _mm_cvttph_epu64(A);
2328 }
2329
2330 __m128i test_mm_mask_cvttph_epu64(__m128i A, __mmask8 B, __m128h C) {
2331 // CHECK-LABEL: test_mm_mask_cvttph_epu64
2332 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.128
2333 return _mm_mask_cvttph_epu64(A, B, C);
2334 }
2335
2336 __m128i test_mm_maskz_cvttph_epu64(__mmask8 A, __m128h B) {
2337 // CHECK-LABEL: test_mm_maskz_cvttph_epu64
2338 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.128
2339 return _mm_maskz_cvttph_epu64(A, B);
2340 }
2341
2342 __m256i test_mm256_cvttph_epu64(__m128h A) {
2343 // CHECK-LABEL: test_mm256_cvttph_epu64
2344 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.256
2345 return _mm256_cvttph_epu64(A);
2346 }
2347
2348 __m256i test_mm256_mask_cvttph_epu64(__m256i A, __mmask8 B, __m128h C) {
2349 // CHECK-LABEL: test_mm256_mask_cvttph_epu64
2350 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.256
2351 return _mm256_mask_cvttph_epu64(A, B, C);
2352 }
2353
2354 __m256i test_mm256_maskz_cvttph_epu64(__mmask8 A, __m128h B) {
2355 // CHECK-LABEL: test_mm256_maskz_cvttph_epu64
2356 // CHECK: @llvm.x86.avx512fp16.mask.vcvttph2uqq.256
2357 return _mm256_maskz_cvttph_epu64(A, B);
2358 }
2359
2360 __m128 test_mm_cvtxph_ps(__m128h A) {
2361 // CHECK-LABEL: test_mm_cvtxph_ps
2362 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.128
2363 return _mm_cvtxph_ps(A);
2364 }
2365
2366 __m128 test_mm_mask_cvtxph_ps(__m128 A, __mmask8 B, __m128h C) {
2367 // CHECK-LABEL: test_mm_mask_cvtxph_ps
2368 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.128
2369 return _mm_mask_cvtxph_ps(A, B, C);
2370 }
2371
2372 __m128 test_mm_maskz_cvtxph_ps(__mmask8 A, __m128h B) {
2373 // CHECK-LABEL: test_mm_maskz_cvtxph_ps
2374 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.128
2375 return _mm_maskz_cvtxph_ps(A, B);
2376 }
2377
2378 __m256 test_mm256_cvtxph_ps(__m128h A) {
2379 // CHECK-LABEL: test_mm256_cvtxph_ps
2380 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.256
2381 return _mm256_cvtxph_ps(A);
2382 }
2383
2384 __m256 test_mm256_mask_cvtxph_ps(__m256 A, __mmask8 B, __m128h C) {
2385 // CHECK-LABEL: test_mm256_mask_cvtxph_ps
2386 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.256
2387 return _mm256_mask_cvtxph_ps(A, B, C);
2388 }
2389
2390 __m256 test_mm256_maskz_cvtxph_ps(__mmask8 A, __m128h B) {
2391 // CHECK-LABEL: test_mm256_maskz_cvtxph_ps
2392 // CHECK: @llvm.x86.avx512fp16.mask.vcvtph2psx.256
2393 return _mm256_maskz_cvtxph_ps(A, B);
2394 }
2395
2396 __m128h test_mm_cvtxps_ph(__m128 A) {
2397 // CHECK-LABEL: test_mm_cvtxps_ph
2398 // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.128
2399 return _mm_cvtxps_ph(A);
2400 }
2401
2402 __m128h test_mm_mask_cvtxps_ph(__m128h A, __mmask8 B, __m128 C) {
2403 // CHECK-LABEL: test_mm_mask_cvtxps_ph
2404 // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.128
2405 return _mm_mask_cvtxps_ph(A, B, C);
2406 }
2407
2408 __m128h test_mm_maskz_cvtxps_ph(__mmask8 A, __m128 B) {
2409 // CHECK-LABEL: test_mm_maskz_cvtxps_ph
2410 // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.128
2411 return _mm_maskz_cvtxps_ph(A, B);
2412 }
2413
2414 __m128h test_mm256_cvtxps_ph(__m256 A) {
2415 // CHECK-LABEL: test_mm256_cvtxps_ph
2416 // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.256
2417 return _mm256_cvtxps_ph(A);
2418 }
2419
2420 __m128h test_mm256_mask_cvtxps_ph(__m128h A, __mmask8 B, __m256 C) {
2421 // CHECK-LABEL: test_mm256_mask_cvtxps_ph
2422 // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.256
2423 return _mm256_mask_cvtxps_ph(A, B, C);
2424 }
2425
2426 __m128h test_mm256_maskz_cvtxps_ph(__mmask8 A, __m256 B) {
2427 // CHECK-LABEL: test_mm256_maskz_cvtxps_ph
2428 // CHECK: @llvm.x86.avx512fp16.mask.vcvtps2phx.256
2429 return _mm256_maskz_cvtxps_ph(A, B);
2430 }
2431
2432 __m128h test_mm_fmadd_ph(__m128h __A, __m128h __B, __m128h __C) {
2433 // CHECK-LABEL: @test_mm_fmadd_ph
2434 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2435 return _mm_fmadd_ph(__A, __B, __C);
2436 }
2437
2438 __m128h test_mm_mask_fmadd_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2439 // CHECK-LABEL: @test_mm_mask_fmadd_ph
2440 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2441 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2442 return _mm_mask_fmadd_ph(__A, __U, __B, __C);
2443 }
2444
2445 __m128h test_mm_fmsub_ph(__m128h __A, __m128h __B, __m128h __C) {
2446 // CHECK-LABEL: @test_mm_fmsub_ph
2447 // CHECK: fneg
2448 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2449 return _mm_fmsub_ph(__A, __B, __C);
2450 }
2451
2452 __m128h test_mm_mask_fmsub_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2453 // CHECK-LABEL: @test_mm_mask_fmsub_ph
2454 // CHECK: fneg
2455 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2456 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2457 return _mm_mask_fmsub_ph(__A, __U, __B, __C);
2458 }
2459
2460 __m128h test_mm_mask3_fmadd_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2461 // CHECK-LABEL: @test_mm_mask3_fmadd_ph
2462 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2463 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2464 return _mm_mask3_fmadd_ph(__A, __B, __C, __U);
2465 }
2466
2467 __m128h test_mm_mask3_fnmadd_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2468 // CHECK-LABEL: @test_mm_mask3_fnmadd_ph
2469 // CHECK: fneg
2470 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2471 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2472 return _mm_mask3_fnmadd_ph(__A, __B, __C, __U);
2473 }
2474
2475 __m128h test_mm_maskz_fmadd_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2476 // CHECK-LABEL: @test_mm_maskz_fmadd_ph
2477 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2478 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2479 return _mm_maskz_fmadd_ph(__U, __A, __B, __C);
2480 }
2481
2482 __m128h test_mm_maskz_fmsub_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2483 // CHECK-LABEL: @test_mm_maskz_fmsub_ph
2484 // CHECK: fneg
2485 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2486 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2487 return _mm_maskz_fmsub_ph(__U, __A, __B, __C);
2488 }
2489
2490 __m128h test_mm_maskz_fnmadd_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2491 // CHECK-LABEL: @test_mm_maskz_fnmadd_ph
2492 // CHECK: fneg
2493 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2494 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2495 return _mm_maskz_fnmadd_ph(__U, __A, __B, __C);
2496 }
2497
2498 __m128h test_mm_maskz_fnmsub_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2499 // CHECK-LABEL: @test_mm_maskz_fnmsub_ph
2500 // CHECK: fneg
2501 // CHECK: fneg
2502 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2503 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2504 return _mm_maskz_fnmsub_ph(__U, __A, __B, __C);
2505 }
2506
2507 __m256h test_mm256_fmadd_ph(__m256h __A, __m256h __B, __m256h __C) {
2508 // CHECK-LABEL: @test_mm256_fmadd_ph
2509 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2510 return _mm256_fmadd_ph(__A, __B, __C);
2511 }
2512
2513 __m256h test_mm256_mask_fmadd_ph(__m256h __A, __mmask8 __U, __m256h __B, __m256h __C) {
2514 // CHECK-LABEL: @test_mm256_mask_fmadd_ph
2515 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2516 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2517 return _mm256_mask_fmadd_ph(__A, __U, __B, __C);
2518 }
2519
2520 __m256h test_mm256_fmsub_ph(__m256h __A, __m256h __B, __m256h __C) {
2521 // CHECK-LABEL: @test_mm256_fmsub_ph
2522 // CHECK: fneg
2523 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2524 return _mm256_fmsub_ph(__A, __B, __C);
2525 }
2526
2527 __m256h test_mm256_mask_fmsub_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
2528 // CHECK-LABEL: @test_mm256_mask_fmsub_ph
2529 // CHECK: fneg
2530 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2531 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2532 return _mm256_mask_fmsub_ph(__A, __U, __B, __C);
2533 }
2534
2535 __m256h test_mm256_mask3_fmadd_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2536 // CHECK-LABEL: @test_mm256_mask3_fmadd_ph
2537 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2538 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2539 return _mm256_mask3_fmadd_ph(__A, __B, __C, __U);
2540 }
2541
2542 __m256h test_mm256_mask3_fnmadd_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2543 // CHECK-LABEL: @test_mm256_mask3_fnmadd_ph
2544 // CHECK: fneg
2545 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2546 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2547 return _mm256_mask3_fnmadd_ph(__A, __B, __C, __U);
2548 }
2549
2550 __m256h test_mm256_maskz_fmadd_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
2551 // CHECK-LABEL: @test_mm256_maskz_fmadd_ph
2552 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2553 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2554 return _mm256_maskz_fmadd_ph(__U, __A, __B, __C);
2555 }
2556
2557 __m256h test_mm256_maskz_fmsub_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
2558 // CHECK-LABEL: @test_mm256_maskz_fmsub_ph
2559 // CHECK: fneg
2560 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2561 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2562 return _mm256_maskz_fmsub_ph(__U, __A, __B, __C);
2563 }
2564
2565 __m256h test_mm256_maskz_fnmadd_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
2566 // CHECK-LABEL: @test_mm256_maskz_fnmadd_ph
2567 // CHECK: fneg
2568 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2569 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2570 return _mm256_maskz_fnmadd_ph(__U, __A, __B, __C);
2571 }
2572
2573 __m256h test_mm256_maskz_fnmsub_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
2574 // CHECK-LABEL: @test_mm256_maskz_fnmsub_ph
2575 // CHECK: fneg
2576 // CHECK: fneg
2577 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2578 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2579 return _mm256_maskz_fnmsub_ph(__U, __A, __B, __C);
2580 }
2581
2582 __m128h test_mm_fmaddsub_ph(__m128h __A, __m128h __B, __m128h __C) {
2583 // CHECK-LABEL: @test_mm_fmaddsub_ph
2584 // CHECK-NOT: fneg
2585 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2586 return _mm_fmaddsub_ph(__A, __B, __C);
2587 }
2588
2589 __m128h test_mm_mask_fmaddsub_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2590 // CHECK-LABEL: @test_mm_mask_fmaddsub_ph
2591 // CHECK-NOT: fneg
2592 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2593 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2594 return _mm_mask_fmaddsub_ph(__A, __U, __B, __C);
2595 }
2596
2597 __m128h test_mm_fmsubadd_ph(__m128h __A, __m128h __B, __m128h __C) {
2598 // CHECK-LABEL: @test_mm_fmsubadd_ph
2599 // CHECK: [[NEG:%.+]] = fneg
2600 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> [[NEG]])
2601 return _mm_fmsubadd_ph(__A, __B, __C);
2602 }
2603
2604 __m128h test_mm_mask_fmsubadd_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2605 // CHECK-LABEL: @test_mm_mask_fmsubadd_ph
2606 // CHECK: [[NEG:%.+]] = fneg
2607 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> [[NEG]])
2608 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2609 return _mm_mask_fmsubadd_ph(__A, __U, __B, __C);
2610 }
2611
2612 __m128h test_mm_mask3_fmaddsub_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2613 // CHECK-LABEL: @test_mm_mask3_fmaddsub_ph
2614 // CHECK-NOT: fneg
2615 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2616 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2617 return _mm_mask3_fmaddsub_ph(__A, __B, __C, __U);
2618 }
2619
2620 __m128h test_mm_maskz_fmaddsub_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2621 // CHECK-LABEL: @test_mm_maskz_fmaddsub_ph
2622 // CHECK-NOT: fneg
2623 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2624 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2625 return _mm_maskz_fmaddsub_ph(__U, __A, __B, __C);
2626 }
2627
2628 __m128h test_mm_maskz_fmsubadd_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2629 // CHECK-LABEL: @test_mm_maskz_fmsubadd_ph
2630 // CHECK: [[NEG:%.+]] = fneg
2631 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> [[NEG]])
2632 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2633 return _mm_maskz_fmsubadd_ph(__U, __A, __B, __C);
2634 }
2635
2636 __m256h test_mm256_fmaddsub_ph(__m256h __A, __m256h __B, __m256h __C) {
2637 // CHECK-LABEL: @test_mm256_fmaddsub_ph
2638 // CHECK-NOT: fneg
2639 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2640 return _mm256_fmaddsub_ph(__A, __B, __C);
2641 }
2642
2643 __m256h test_mm256_mask_fmaddsub_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
2644 // CHECK-LABEL: @test_mm256_mask_fmaddsub_ph
2645 // CHECK-NOT: fneg
2646 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2647 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2648 return _mm256_mask_fmaddsub_ph(__A, __U, __B, __C);
2649 }
2650
2651 __m256h test_mm256_fmsubadd_ph(__m256h __A, __m256h __B, __m256h __C) {
2652 // CHECK-LABEL: @test_mm256_fmsubadd_ph
2653 // CHECK: [[NEG:%.+]] = fneg
2654 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> [[NEG]])
2655 return _mm256_fmsubadd_ph(__A, __B, __C);
2656 }
2657
2658 __m256h test_mm256_mask_fmsubadd_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
2659 // CHECK-LABEL: @test_mm256_mask_fmsubadd_ph
2660 // CHECK: [[NEG:%.+]] = fneg
2661 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> [[NEG]])
2662 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2663 return _mm256_mask_fmsubadd_ph(__A, __U, __B, __C);
2664 }
2665
2666 __m256h test_mm256_mask3_fmaddsub_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2667 // CHECK-LABEL: @test_mm256_mask3_fmaddsub_ph
2668 // CHECK-NOT: fneg
2669 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2670 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2671 return _mm256_mask3_fmaddsub_ph(__A, __B, __C, __U);
2672 }
2673
2674 __m256h test_mm256_maskz_fmaddsub_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
2675 // CHECK-LABEL: @test_mm256_maskz_fmaddsub_ph
2676 // CHECK-NOT: fneg
2677 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2678 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2679 return _mm256_maskz_fmaddsub_ph(__U, __A, __B, __C);
2680 }
2681
2682 __m256h test_mm256_maskz_fmsubadd_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
2683 // CHECK-LABEL: @test_mm256_maskz_fmsubadd_ph
2684 // CHECK: [[NEG:%.+]] = fneg
2685 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> [[NEG]])
2686 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2687 return _mm256_maskz_fmsubadd_ph(__U, __A, __B, __C);
2688 }
2689
2690 __m128h test_mm_mask3_fmsub_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2691 // CHECK-LABEL: @test_mm_mask3_fmsub_ph
2692 // CHECK: fneg
2693 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2694 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2695 return _mm_mask3_fmsub_ph(__A, __B, __C, __U);
2696 }
2697
2698 __m256h test_mm256_mask3_fmsub_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2699 // CHECK-LABEL: @test_mm256_mask3_fmsub_ph
2700 // CHECK: fneg
2701 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2702 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2703 return _mm256_mask3_fmsub_ph(__A, __B, __C, __U);
2704 }
2705
2706 __m128h test_mm_mask3_fmsubadd_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2707 // CHECK-LABEL: @test_mm_mask3_fmsubadd_ph
2708 // CHECK: [[NEG:%.+]] = fneg
2709 // CHECK: call <8 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> [[NEG]])
2710 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2711 return _mm_mask3_fmsubadd_ph(__A, __B, __C, __U);
2712 }
2713
2714 __m256h test_mm256_mask3_fmsubadd_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2715 // CHECK-LABEL: @test_mm256_mask3_fmsubadd_ph
2716 // CHECK: [[NEG:%.+]] = fneg
2717 // CHECK: call <16 x half> @llvm.x86.avx512fp16.vfmaddsub.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> [[NEG]])
2718 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2719 return _mm256_mask3_fmsubadd_ph(__A, __B, __C, __U);
2720 }
2721
2722 __m128h test_mm_fnmadd_ph(__m128h __A, __m128h __B, __m128h __C) {
2723 // CHECK-LABEL: @test_mm_fnmadd_ph
2724 // CHECK: fneg
2725 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2726 return _mm_fnmadd_ph(__A, __B, __C);
2727 }
2728
2729 __m128h test_mm_mask_fnmadd_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2730 // CHECK-LABEL: @test_mm_mask_fnmadd_ph
2731 // CHECK: fneg
2732 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2733 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2734 return _mm_mask_fnmadd_ph(__A, __U, __B, __C);
2735 }
2736
2737 __m256h test_mm256_fnmadd_ph(__m256h __A, __m256h __B, __m256h __C) {
2738 // CHECK-LABEL: @test_mm256_fnmadd_ph
2739 // CHECK: fneg
2740 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2741 return _mm256_fnmadd_ph(__A, __B, __C);
2742 }
2743
2744 __m256h test_mm256_mask_fnmadd_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
2745 // CHECK-LABEL: @test_mm256_mask_fnmadd_ph
2746 // CHECK: fneg
2747 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2748 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2749 return _mm256_mask_fnmadd_ph(__A, __U, __B, __C);
2750 }
2751
2752 __m128h test_mm_fnmsub_ph(__m128h __A, __m128h __B, __m128h __C) {
2753 // CHECK-LABEL: @test_mm_fnmsub_ph
2754 // CHECK: fneg
2755 // CHECK: fneg
2756 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2757 return _mm_fnmsub_ph(__A, __B, __C);
2758 }
2759
2760 __m128h test_mm_mask_fnmsub_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2761 // CHECK-LABEL: @test_mm_mask_fnmsub_ph
2762 // CHECK: fneg
2763 // CHECK: fneg
2764 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2765 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2766 return _mm_mask_fnmsub_ph(__A, __U, __B, __C);
2767 }
2768
2769 __m128h test_mm_mask3_fnmsub_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2770 // CHECK-LABEL: @test_mm_mask3_fnmsub_ph
2771 // CHECK: fneg
2772 // CHECK: fneg
2773 // CHECK: call <8 x half> @llvm.fma.v8f16(<8 x half> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}})
2774 // CHECK: select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2775 return _mm_mask3_fnmsub_ph(__A, __B, __C, __U);
2776 }
2777
2778 __m256h test_mm256_fnmsub_ph(__m256h __A, __m256h __B, __m256h __C) {
2779 // CHECK-LABEL: @test_mm256_fnmsub_ph
2780 // CHECK: fneg
2781 // CHECK: fneg
2782 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2783 return _mm256_fnmsub_ph(__A, __B, __C);
2784 }
2785
2786 __m256h test_mm256_mask_fnmsub_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
2787 // CHECK-LABEL: @test_mm256_mask_fnmsub_ph
2788 // CHECK: fneg
2789 // CHECK: fneg
2790 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2791 // CHECK: select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2792 return _mm256_mask_fnmsub_ph(__A, __U, __B, __C);
2793 }
2794
2795 __m256h test_mm256_mask3_fnmsub_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
2796 // CHECK-LABEL: @test_mm256_mask3_fnmsub_ph
2797 // CHECK: fneg
2798 // CHECK: fneg
2799 // CHECK: call <16 x half> @llvm.fma.v16f16(<16 x half> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}})
2800 return _mm256_mask3_fnmsub_ph(__A, __B, __C, __U);
2801 }
2802
2803 __m128h test_mm_fcmul_pch(__m128h __A, __m128h __B) {
2804 // CHECK-LABEL: @test_mm_fcmul_pch
2805 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.128
2806 return _mm_fcmul_pch(__A, __B);
2807 }
2808
2809 __m128h test_mm_mask_fcmul_pch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2810 // CHECK-LABEL: @test_mm_mask_fcmul_pch
2811 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.128
2812 return _mm_mask_fcmul_pch(__W, __U, __A, __B);
2813 }
2814
2815 __m128h test_mm_maskz_fcmul_pch(__mmask8 __U, __m128h __A, __m128h __B) {
2816 // CHECK-LABEL: @test_mm_maskz_fcmul_pch
2817 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.128
2818 return _mm_maskz_fcmul_pch(__U, __A, __B);
2819 }
2820
2821 __m256h test_mm256_fcmul_pch(__m256h __A, __m256h __B) {
2822 // CHECK-LABEL: @test_mm256_fcmul_pch
2823 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.256
2824 return _mm256_fcmul_pch(__A, __B);
2825 }
2826
2827 __m256h test_mm256_mask_fcmul_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
2828 // CHECK-LABEL: @test_mm256_mask_fcmul_pch
2829 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.256
2830 return _mm256_mask_fcmul_pch(__W, __U, __A, __B);
2831 }
2832
2833 __m256h test_mm256_maskz_fcmul_pch(__mmask8 __U, __m256h __A, __m256h __B) {
2834 // CHECK-LABEL: @test_mm256_maskz_fcmul_pch
2835 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.256
2836 return _mm256_maskz_fcmul_pch(__U, __A, __B);
2837 }
2838
2839 __m128h test_mm_fcmadd_pch(__m128h __A, __m128h __B, __m128h __C) {
2840 // CHECK-LABEL: @test_mm_fcmadd_pch
2841 // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.128
2842 return _mm_fcmadd_pch(__A, __B, __C);
2843 }
2844
2845 __m128h test_mm_mask_fcmadd_pch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2846 // CHECK-LABEL: @test_mm_mask_fcmadd_pch
2847 // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.128
2848 // CHECK: %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2849 // CHECK: %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
2850 return _mm_mask_fcmadd_pch(__A, __U, __B, __C);
2851 }
2852
2853 __m128h test_mm_mask3_fcmadd_pch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2854 // CHECK-LABEL: @test_mm_mask3_fcmadd_pch
2855 // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.128
2856 // CHECK-NOT: %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
2857 return _mm_mask3_fcmadd_pch(__A, __B, __C, __U);
2858 }
2859
2860 __m128h test_mm_maskz_fcmadd_pch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2861 // CHECK-LABEL: @test_mm_maskz_fcmadd_pch
2862 // CHECK: @llvm.x86.avx512fp16.maskz.vfcmadd.cph.128
2863 return _mm_maskz_fcmadd_pch(__U, __A, __B, __C);
2864 }
2865
2866 __m256h test_mm256_fcmadd_pch(__m256h __A, __m256h __B, __m256h __C) {
2867 // CHECK-LABEL: @test_mm256_fcmadd_pch
2868 // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.256
2869 return _mm256_fcmadd_pch(__A, __B, __C);
2870 }
2871
2872 __m256h test_mm256_mask_fcmadd_pch(__m256h __A, __mmask8 __U, __m256h __B, __m256h __C) {
2873 // CHECK-LABEL: @test_mm256_mask_fcmadd_pch
2874 // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.256
2875 // CHECK: %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2876 return _mm256_mask_fcmadd_pch(__A, __U, __B, __C);
2877 }
2878
2879 __m256h test_mm256_mask3_fcmadd_pch(__m256h __A, __m256h __B, __m256h __C, __mmask8 __U) {
2880 // CHECK-LABEL: @test_mm256_mask3_fcmadd_pch
2881 // CHECK: @llvm.x86.avx512fp16.mask.vfcmadd.cph.256
2882 // CHECK-NOT: %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2883 return _mm256_mask3_fcmadd_pch(__A, __B, __C, __U);
2884 }
2885
2886 __m256h test_mm256_maskz_fcmadd_pch(__mmask8 __U, __m256h __A, __m256h __B, __m256h __C) {
2887 // CHECK-LABEL: @test_mm256_maskz_fcmadd_pch
2888 // CHECK: @llvm.x86.avx512fp16.maskz.vfcmadd.cph.256
2889 return _mm256_maskz_fcmadd_pch(__U, __A, __B, __C);
2890 }
2891
2892 __m128h test_mm_fmul_pch(__m128h __A, __m128h __B) {
2893 // CHECK-LABEL: @test_mm_fmul_pch
2894 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.128
2895 return _mm_fmul_pch(__A, __B);
2896 }
2897
2898 __m128h test_mm_mask_fmul_pch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2899 // CHECK-LABEL: @test_mm_mask_fmul_pch
2900 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.128
2901 return _mm_mask_fmul_pch(__W, __U, __A, __B);
2902 }
2903
2904 __m128h test_mm_maskz_fmul_pch(__mmask8 __U, __m128h __A, __m128h __B) {
2905 // CHECK-LABEL: @test_mm_maskz_fmul_pch
2906 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.128
2907 return _mm_maskz_fmul_pch(__U, __A, __B);
2908 }
2909
2910 __m256h test_mm256_fmul_pch(__m256h __A, __m256h __B) {
2911 // CHECK-LABEL: @test_mm256_fmul_pch
2912 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.256
2913 return _mm256_fmul_pch(__A, __B);
2914 }
2915
2916 __m256h test_mm256_mask_fmul_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
2917 // CHECK-LABEL: @test_mm256_mask_fmul_pch
2918 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.256
2919 return _mm256_mask_fmul_pch(__W, __U, __A, __B);
2920 }
2921
2922 __m256h test_mm256_maskz_fmul_pch(__mmask8 __U, __m256h __A, __m256h __B) {
2923 // CHECK-LABEL: @test_mm256_maskz_fmul_pch
2924 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.256
2925 return _mm256_maskz_fmul_pch(__U, __A, __B);
2926 }
2927
2928 __m128h test_mm_fmadd_pch(__m128h __A, __m128h __B, __m128h __C) {
2929 // CHECK-LABEL: @test_mm_fmadd_pch
2930 // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.128
2931 return _mm_fmadd_pch(__A, __B, __C);
2932 }
2933
2934 __m128h test_mm_mask_fmadd_pch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2935 // CHECK-LABEL: @test_mm_mask_fmadd_pch
2936 // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.128
2937 // CHECK: %{{.*}} = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
2938 // CHECK: %{{.*}} = select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
2939 return _mm_mask_fmadd_pch(__A, __U, __B, __C);
2940 }
2941
2942 __m128h test_mm_mask3_fmadd_pch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2943 // CHECK-LABEL: @test_mm_mask3_fmadd_pch
2944 // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.128
2945 return _mm_mask3_fmadd_pch(__A, __B, __C, __U);
2946 }
2947
2948 __m128h test_mm_maskz_fmadd_pch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2949 // CHECK-LABEL: @test_mm_maskz_fmadd_pch
2950 // CHECK: @llvm.x86.avx512fp16.maskz.vfmadd.cph.128
2951 return _mm_maskz_fmadd_pch(__U, __A, __B, __C);
2952 }
2953
2954 __m256h test_mm256_fmadd_pch(__m256h __A, __m256h __B, __m256h __C) {
2955 // CHECK-LABEL: @test_mm256_fmadd_pch
2956 // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.256
2957 return _mm256_fmadd_pch(__A, __B, __C);
2958 }
2959
2960 __m256h test_mm256_mask_fmadd_pch(__m256h __A, __mmask8 __U, __m256h __B, __m256h __C) {
2961 // CHECK-LABEL: @test_mm256_mask_fmadd_pch
2962 // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.256
2963 // CHECK: %{{.*}} = select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
2964 return _mm256_mask_fmadd_pch(__A, __U, __B, __C);
2965 }
2966
2967 __m256h test_mm256_mask3_fmadd_pch(__m256h __A, __m256h __B, __m256h __C, __mmask8 __U) {
2968 // CHECK-LABEL: @test_mm256_mask3_fmadd_pch
2969 // CHECK: @llvm.x86.avx512fp16.mask.vfmadd.cph.256
2970 return _mm256_mask3_fmadd_pch(__A, __B, __C, __U);
2971 }
2972
2973 __m256h test_mm256_maskz_fmadd_pch(__mmask8 __U, __m256h __A, __m256h __B, __m256h __C) {
2974 // CHECK-LABEL: @test_mm256_maskz_fmadd_pch
2975 // CHECK: @llvm.x86.avx512fp16.maskz.vfmadd.cph.256
2976 return _mm256_maskz_fmadd_pch(__U, __A, __B, __C);
2977 }
2978
2979 __m128h test_mm_mask_blend_ph(__mmask8 __U, __m128h __A, __m128h __W) {
2980 // CHECK-LABEL: @test_mm_mask_blend_ph
2981 // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
2982 // CHECK: %{{.*}} = select <8 x i1> %{{.*}}, <8 x half> %{{.*}}, <8 x half> %{{.*}}
2983 return _mm_mask_blend_ph(__U, __A, __W);
2984 }
2985
2986 __m256h test_mm256_mask_blend_ph(__mmask16 __U, __m256h __A, __m256h __W) {
2987 // CHECK-LABEL: @test_mm256_mask_blend_ph
2988 // CHECK: %{{.*}} = bitcast i16 %{{.*}} to <16 x i1>
2989 // CHECK: %{{.*}} = select <16 x i1> %{{.*}}, <16 x half> %{{.*}}, <16 x half> %{{.*}}
2990 return _mm256_mask_blend_ph(__U, __A, __W);
2991 }
2992
2993 __m128h test_mm_permutex2var_ph(__m128h __A, __m128i __I, __m128h __B) {
2994 // CHECK-LABEL: @test_mm_permutex2var_ph
2995 // CHECK: %{{.*}} = bitcast <8 x half> %{{.*}} to <8 x i16>
2996 // CHECK: %{{.*}} = bitcast <2 x i64> %{{.*}} to <8 x i16>
2997 // CHECK: %{{.*}} = bitcast <8 x half> %{{.*}} to <8 x i16>
2998 // CHECK: %{{.*}} = call <8 x i16> @llvm.x86.avx512.vpermi2var.hi.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i16> %{{.*}})
2999 // CHECK: %{{.*}} = bitcast <8 x i16> %{{.*}} to <8 x half>
3000 return _mm_permutex2var_ph(__A, __I, __B);
3001 }
3002
3003 __m256h test_mm256_permutex2var_ph(__m256h __A, __m256i __I, __m256h __B) {
3004 // CHECK-LABEL: @test_mm256_permutex2var_ph
3005 // CHECK: %{{.*}} = bitcast <16 x half> %{{.*}} to <16 x i16>
3006 // CHECK: %{{.*}} = bitcast <4 x i64> %{{.*}} to <16 x i16>
3007 // CHECK: %{{.*}} = bitcast <16 x half> %{{.*}} to <16 x i16>
3008 // CHECK: %{{.*}} = call <16 x i16> @llvm.x86.avx512.vpermi2var.hi.256(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i16> %{{.*}})
3009 // CHECK: %{{.*}} = bitcast <16 x i16> %{{.*}} to <16 x half>
3010 return _mm256_permutex2var_ph(__A, __I, __B);
3011 }
3012
3013 __m128h test_mm_permutexvar_ph(__m128i __A, __m128h __B) {
3014 // CHECK-LABEL: @test_mm_permutexvar_ph
3015 // CHECK: %{{.*}} = bitcast <8 x half> %{{.*}} to <8 x i16>
3016 // CHECK: %{{.*}} = bitcast <2 x i64> %{{.*}} to <8 x i16>
3017 // CHECK: %{{.*}} = call <8 x i16> @llvm.x86.avx512.permvar.hi.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}})
3018 // CHECK: %{{.*}} = bitcast <8 x i16> %{{.*}} to <8 x half>
3019 return _mm_permutexvar_ph(__A, __B);
3020 }
3021
3022 __m256h test_mm256_permutexvar_ph(__m256i __A, __m256h __B) {
3023 // CHECK-LABEL: @test_mm256_permutexvar_ph
3024 // CHECK: %{{.*}} = bitcast <16 x half> %{{.*}} to <16 x i16>
3025 // CHECK: %{{.*}} = bitcast <4 x i64> %{{.*}} to <16 x i16>
3026 // CHECK: %{{.*}} = call <16 x i16> @llvm.x86.avx512.permvar.hi.256(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
3027 // CHECK: %{{.*}} = bitcast <16 x i16> %{{.*}} to <16 x half>
3028 return _mm256_permutexvar_ph(__A, __B);
3029 }
3030
3031 _Float16 test_mm256_reduce_add_ph(__m256h __W) {
3032 // CHECK-LABEL: @test_mm256_reduce_add_ph
3033 // CHECK: call reassoc half @llvm.vector.reduce.fadd.v16f16(half 0xH8000, <16 x half> %{{.*}})
3034 return _mm256_reduce_add_ph(__W);
3035 }
3036
3037 _Float16 test_mm256_reduce_mul_ph(__m256h __W) {
3038 // CHECK-LABEL: @test_mm256_reduce_mul_ph
3039 // CHECK: call reassoc half @llvm.vector.reduce.fmul.v16f16(half 0xH3C00, <16 x half> %{{.*}})
3040 return _mm256_reduce_mul_ph(__W);
3041 }
3042
3043 _Float16 test_mm256_reduce_max_ph(__m256h __W) {
3044 // CHECK-LABEL: @test_mm256_reduce_max_ph
3045 // CHECK: call nnan half @llvm.vector.reduce.fmax.v16f16(<16 x half> %{{.*}})
3046 return _mm256_reduce_max_ph(__W);
3047 }
3048
3049 _Float16 test_mm256_reduce_min_ph(__m256h __W) {
3050 // CHECK-LABEL: @test_mm256_reduce_min_ph
3051 // CHECK: call nnan half @llvm.vector.reduce.fmin.v16f16(<16 x half> %{{.*}})
3052 return _mm256_reduce_min_ph(__W);
3053 }
3054
3055 _Float16 test_mm_reduce_add_ph(__m128h __W) {
3056 // CHECK-LABEL: @test_mm_reduce_add_ph
3057 // CHECK: call reassoc half @llvm.vector.reduce.fadd.v8f16(half 0xH8000, <8 x half> %{{.*}})
3058 return _mm_reduce_add_ph(__W);
3059 }
3060
3061 _Float16 test_mm_reduce_mul_ph(__m128h __W) {
3062 // CHECK-LABEL: @test_mm_reduce_mul_ph
3063 // CHECK: call reassoc half @llvm.vector.reduce.fmul.v8f16(half 0xH3C00, <8 x half> %{{.*}})
3064 return _mm_reduce_mul_ph(__W);
3065 }
3066
3067 _Float16 test_mm_reduce_min_ph(__m128h __W) {
3068 // CHECK-LABEL: @test_mm_reduce_min_ph
3069 // CHECK: call nnan half @llvm.vector.reduce.fmin.v8f16(<8 x half> %{{.*}})
3070 return _mm_reduce_min_ph(__W);
3071 }
3072
3073 _Float16 test_mm_reduce_max_ph(__m128h __W) {
3074 // CHECK-LABEL: @test_mm_reduce_max_ph
3075 // CHECK: call nnan half @llvm.vector.reduce.fmax.v8f16(<8 x half> %{{.*}})
3076 return _mm_reduce_max_ph(__W);
3077 }
3078
3079 // tests below are for alias intrinsics.
3080 __m128h test_mm_mul_pch(__m128h __A, __m128h __B) {
3081 // CHECK-LABEL: @test_mm_mul_pch
3082 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.128
3083 return _mm_mul_pch(__A, __B);
3084 }
3085
3086 __m128h test_mm_mask_mul_pch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3087 // CHECK-LABEL: @test_mm_mask_mul_pch
3088 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.128
3089 return _mm_mask_mul_pch(__W, __U, __A, __B);
3090 }
3091
3092 __m128h test_mm_maskz_mul_pch(__mmask8 __U, __m128h __A, __m128h __B) {
3093 // CHECK-LABEL: @test_mm_maskz_mul_pch
3094 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.128
3095 return _mm_maskz_mul_pch(__U, __A, __B);
3096 }
3097
3098 __m256h test_mm256_mul_pch(__m256h __A, __m256h __B) {
3099 // CHECK-LABEL: @test_mm256_mul_pch
3100 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.256
3101 return _mm256_mul_pch(__A, __B);
3102 }
3103
3104 __m256h test_mm256_mask_mul_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
3105 // CHECK-LABEL: @test_mm256_mask_mul_pch
3106 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.256
3107 return _mm256_mask_mul_pch(__W, __U, __A, __B);
3108 }
3109
3110 __m256h test_mm256_maskz_mul_pch(__mmask8 __U, __m256h __A, __m256h __B) {
3111 // CHECK-LABEL: @test_mm256_maskz_mul_pch
3112 // CHECK: @llvm.x86.avx512fp16.mask.vfmul.cph.256
3113 return _mm256_maskz_mul_pch(__U, __A, __B);
3114 }
3115
3116 __m128h test_mm_cmul_pch(__m128h __A, __m128h __B) {
3117 // CHECK-LABEL: @test_mm_cmul_pch
3118 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.128
3119 return _mm_cmul_pch(__A, __B);
3120 }
3121
3122 __m128h test_mm_mask_cmul_pch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3123 // CHECK-LABEL: @test_mm_mask_cmul_pch
3124 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.128
3125 return _mm_mask_fcmul_pch(__W, __U, __A, __B);
3126 }
3127
3128 __m128h test_mm_maskz_cmul_pch(__mmask8 __U, __m128h __A, __m128h __B) {
3129 // CHECK-LABEL: @test_mm_maskz_cmul_pch
3130 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.128
3131 return _mm_maskz_cmul_pch(__U, __A, __B);
3132 }
3133
3134 __m256h test_mm256_cmul_pch(__m256h __A, __m256h __B) {
3135 // CHECK-LABEL: @test_mm256_cmul_pch
3136 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.256
3137 return _mm256_cmul_pch(__A, __B);
3138 }
3139
3140 __m256h test_mm256_mask_cmul_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
3141 // CHECK-LABEL: @test_mm256_mask_cmul_pch
3142 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.256
3143 return _mm256_mask_cmul_pch(__W, __U, __A, __B);
3144 }
3145
3146 __m256h test_mm256_maskz_cmul_pch(__mmask8 __U, __m256h __A, __m256h __B) {
3147 // CHECK-LABEL: @test_mm256_maskz_cmul_pch
3148 // CHECK: @llvm.x86.avx512fp16.mask.vfcmul.cph.256
3149 return _mm256_maskz_cmul_pch(__U, __A, __B);
3150 }
LLVM monorepo