?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[clang] Handle __declspec() attributes in using
[llvm-project.git] / clang / lib / Headers / avx512fp16intrin.h
blob5cdc37fde629fb5675d3681d2015a84efebb1461
1 /*===----------- avx512fp16intrin.h - AVX512-FP16 intrinsics ---------------===
2 *
3 * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 * See https://llvm.org/LICENSE.txt for license information.
5 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 *
7 *===-----------------------------------------------------------------------===
8 */
9 #ifndef __IMMINTRIN_H
10 #error "Never use <avx512fp16intrin.h> directly; include <immintrin.h> instead."
11 #endif
12
13 #ifdef __SSE2__
14
15 #ifndef __AVX512FP16INTRIN_H
16 #define __AVX512FP16INTRIN_H
17
18 /* Define the default attributes for the functions in this file. */
19 typedef _Float16 __v32hf __attribute__((__vector_size__(64), __aligned__(64)));
20 typedef _Float16 __m512h __attribute__((__vector_size__(64), __aligned__(64)));
21 typedef _Float16 __m512h_u __attribute__((__vector_size__(64), __aligned__(1)));
22
23 /* Define the default attributes for the functions in this file. */
24 #define __DEFAULT_FN_ATTRS512 \
25 __attribute__((__always_inline__, __nodebug__, __target__("avx512fp16"), \
26 __min_vector_width__(512)))
27 #define __DEFAULT_FN_ATTRS256 \
28 __attribute__((__always_inline__, __nodebug__, __target__("avx512fp16"), \
29 __min_vector_width__(256)))
30 #define __DEFAULT_FN_ATTRS128 \
31 __attribute__((__always_inline__, __nodebug__, __target__("avx512fp16"), \
32 __min_vector_width__(128)))
33
34 static __inline__ _Float16 __DEFAULT_FN_ATTRS512 _mm512_cvtsh_h(__m512h __a) {
35 return __a[0];
36 }
37
38 static __inline __m128h __DEFAULT_FN_ATTRS128 _mm_setzero_ph(void) {
39 return (__m128h){0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
40 }
41
42 static __inline __m256h __DEFAULT_FN_ATTRS256 _mm256_setzero_ph(void) {
43 return (__m256h){0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
44 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
45 }
46
47 static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_undefined_ph(void) {
48 return (__m256h)__builtin_ia32_undef256();
49 }
50
51 static __inline __m512h __DEFAULT_FN_ATTRS512 _mm512_setzero_ph(void) {
52 return (__m512h){0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
53 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
54 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
55 }
56
57 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_undefined_ph(void) {
58 return (__m128h)__builtin_ia32_undef128();
59 }
60
61 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_undefined_ph(void) {
62 return (__m512h)__builtin_ia32_undef512();
63 }
64
65 static __inline __m512h __DEFAULT_FN_ATTRS512 _mm512_set1_ph(_Float16 __h) {
66 return (__m512h)(__v32hf){__h, __h, __h, __h, __h, __h, __h, __h,
67 __h, __h, __h, __h, __h, __h, __h, __h,
68 __h, __h, __h, __h, __h, __h, __h, __h,
69 __h, __h, __h, __h, __h, __h, __h, __h};
70 }
71
72 static __inline __m512h __DEFAULT_FN_ATTRS512
73 _mm512_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
74 _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8,
75 _Float16 __h9, _Float16 __h10, _Float16 __h11, _Float16 __h12,
76 _Float16 __h13, _Float16 __h14, _Float16 __h15, _Float16 __h16,
77 _Float16 __h17, _Float16 __h18, _Float16 __h19, _Float16 __h20,
78 _Float16 __h21, _Float16 __h22, _Float16 __h23, _Float16 __h24,
79 _Float16 __h25, _Float16 __h26, _Float16 __h27, _Float16 __h28,
80 _Float16 __h29, _Float16 __h30, _Float16 __h31, _Float16 __h32) {
81 return (__m512h)(__v32hf){__h32, __h31, __h30, __h29, __h28, __h27, __h26,
82 __h25, __h24, __h23, __h22, __h21, __h20, __h19,
83 __h18, __h17, __h16, __h15, __h14, __h13, __h12,
84 __h11, __h10, __h9, __h8, __h7, __h6, __h5,
85 __h4, __h3, __h2, __h1};
86 }
87
88 #define _mm512_setr_ph(h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11, h12, h13, \
89 h14, h15, h16, h17, h18, h19, h20, h21, h22, h23, h24, \
90 h25, h26, h27, h28, h29, h30, h31, h32) \
91 _mm512_set_ph((h32), (h31), (h30), (h29), (h28), (h27), (h26), (h25), (h24), \
92 (h23), (h22), (h21), (h20), (h19), (h18), (h17), (h16), (h15), \
93 (h14), (h13), (h12), (h11), (h10), (h9), (h8), (h7), (h6), \
94 (h5), (h4), (h3), (h2), (h1))
95
96 static __inline __m512h __DEFAULT_FN_ATTRS512
97 _mm512_set1_pch(_Float16 _Complex h) {
98 return (__m512h)_mm512_set1_ps(__builtin_bit_cast(float, h));
99 }
100
101 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_castph_ps(__m128h __a) {
102 return (__m128)__a;
103 }
104
105 static __inline__ __m256 __DEFAULT_FN_ATTRS256 _mm256_castph_ps(__m256h __a) {
106 return (__m256)__a;
107 }
108
109 static __inline__ __m512 __DEFAULT_FN_ATTRS512 _mm512_castph_ps(__m512h __a) {
110 return (__m512)__a;
111 }
112
113 static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_castph_pd(__m128h __a) {
114 return (__m128d)__a;
115 }
116
117 static __inline__ __m256d __DEFAULT_FN_ATTRS256 _mm256_castph_pd(__m256h __a) {
118 return (__m256d)__a;
119 }
120
121 static __inline__ __m512d __DEFAULT_FN_ATTRS512 _mm512_castph_pd(__m512h __a) {
122 return (__m512d)__a;
123 }
124
125 static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_castph_si128(__m128h __a) {
126 return (__m128i)__a;
127 }
128
129 static __inline__ __m256i __DEFAULT_FN_ATTRS256
130 _mm256_castph_si256(__m256h __a) {
131 return (__m256i)__a;
132 }
133
134 static __inline__ __m512i __DEFAULT_FN_ATTRS512
135 _mm512_castph_si512(__m512h __a) {
136 return (__m512i)__a;
137 }
138
139 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_castps_ph(__m128 __a) {
140 return (__m128h)__a;
141 }
142
143 static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_castps_ph(__m256 __a) {
144 return (__m256h)__a;
145 }
146
147 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_castps_ph(__m512 __a) {
148 return (__m512h)__a;
149 }
150
151 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_castpd_ph(__m128d __a) {
152 return (__m128h)__a;
153 }
154
155 static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_castpd_ph(__m256d __a) {
156 return (__m256h)__a;
157 }
158
159 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_castpd_ph(__m512d __a) {
160 return (__m512h)__a;
161 }
162
163 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_castsi128_ph(__m128i __a) {
164 return (__m128h)__a;
165 }
166
167 static __inline__ __m256h __DEFAULT_FN_ATTRS256
168 _mm256_castsi256_ph(__m256i __a) {
169 return (__m256h)__a;
170 }
171
172 static __inline__ __m512h __DEFAULT_FN_ATTRS512
173 _mm512_castsi512_ph(__m512i __a) {
174 return (__m512h)__a;
175 }
176
177 static __inline__ __m128h __DEFAULT_FN_ATTRS256
178 _mm256_castph256_ph128(__m256h __a) {
179 return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7);
180 }
181
182 static __inline__ __m128h __DEFAULT_FN_ATTRS512
183 _mm512_castph512_ph128(__m512h __a) {
184 return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7);
185 }
186
187 static __inline__ __m256h __DEFAULT_FN_ATTRS512
188 _mm512_castph512_ph256(__m512h __a) {
189 return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
190 12, 13, 14, 15);
191 }
192
193 static __inline__ __m256h __DEFAULT_FN_ATTRS256
194 _mm256_castph128_ph256(__m128h __a) {
195 return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1,
196 -1, -1, -1, -1, -1);
197 }
198
199 static __inline__ __m512h __DEFAULT_FN_ATTRS512
200 _mm512_castph128_ph512(__m128h __a) {
201 return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7, -1, -1, -1,
202 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
203 -1, -1, -1, -1, -1, -1, -1, -1, -1);
204 }
205
206 static __inline__ __m512h __DEFAULT_FN_ATTRS512
207 _mm512_castph256_ph512(__m256h __a) {
208 return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
209 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1,
210 -1, -1, -1, -1, -1, -1, -1, -1);
211 }
212
213 /// Constructs a 256-bit floating-point vector of [16 x half] from a
214 /// 128-bit floating-point vector of [8 x half]. The lower 128 bits
215 /// contain the value of the source vector. The upper 384 bits are set
216 /// to zero.
217 ///
218 /// \headerfile <x86intrin.h>
219 ///
220 /// This intrinsic has no corresponding instruction.
221 ///
222 /// \param __a
223 /// A 128-bit vector of [8 x half].
224 /// \returns A 512-bit floating-point vector of [16 x half]. The lower 128 bits
225 /// contain the value of the parameter. The upper 384 bits are set to zero.
226 static __inline__ __m256h __DEFAULT_FN_ATTRS256
227 _mm256_zextph128_ph256(__m128h __a) {
228 return __builtin_shufflevector(__a, (__v8hf)_mm_setzero_ph(), 0, 1, 2, 3, 4,
229 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
230 }
231
232 /// Constructs a 512-bit floating-point vector of [32 x half] from a
233 /// 128-bit floating-point vector of [8 x half]. The lower 128 bits
234 /// contain the value of the source vector. The upper 384 bits are set
235 /// to zero.
236 ///
237 /// \headerfile <x86intrin.h>
238 ///
239 /// This intrinsic has no corresponding instruction.
240 ///
241 /// \param __a
242 /// A 128-bit vector of [8 x half].
243 /// \returns A 512-bit floating-point vector of [32 x half]. The lower 128 bits
244 /// contain the value of the parameter. The upper 384 bits are set to zero.
245 static __inline__ __m512h __DEFAULT_FN_ATTRS512
246 _mm512_zextph128_ph512(__m128h __a) {
247 return __builtin_shufflevector(
248 __a, (__v8hf)_mm_setzero_ph(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
249 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15);
250 }
251
252 /// Constructs a 512-bit floating-point vector of [32 x half] from a
253 /// 256-bit floating-point vector of [16 x half]. The lower 256 bits
254 /// contain the value of the source vector. The upper 256 bits are set
255 /// to zero.
256 ///
257 /// \headerfile <x86intrin.h>
258 ///
259 /// This intrinsic has no corresponding instruction.
260 ///
261 /// \param __a
262 /// A 256-bit vector of [16 x half].
263 /// \returns A 512-bit floating-point vector of [32 x half]. The lower 256 bits
264 /// contain the value of the parameter. The upper 256 bits are set to zero.
265 static __inline__ __m512h __DEFAULT_FN_ATTRS512
266 _mm512_zextph256_ph512(__m256h __a) {
267 return __builtin_shufflevector(__a, (__v16hf)_mm256_setzero_ph(), 0, 1, 2, 3,
268 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
269 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
270 29, 30, 31);
271 }
272
273 #define _mm_comi_round_sh(A, B, P, R) \
274 __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, (int)(P), (int)(R))
275
276 #define _mm_comi_sh(A, B, pred) \
277 _mm_comi_round_sh((A), (B), (pred), _MM_FROUND_CUR_DIRECTION)
278
279 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comieq_sh(__m128h A,
280 __m128h B) {
281 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_EQ_OS,
282 _MM_FROUND_CUR_DIRECTION);
283 }
284
285 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comilt_sh(__m128h A,
286 __m128h B) {
287 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LT_OS,
288 _MM_FROUND_CUR_DIRECTION);
289 }
290
291 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comile_sh(__m128h A,
292 __m128h B) {
293 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LE_OS,
294 _MM_FROUND_CUR_DIRECTION);
295 }
296
297 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comigt_sh(__m128h A,
298 __m128h B) {
299 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GT_OS,
300 _MM_FROUND_CUR_DIRECTION);
301 }
302
303 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comige_sh(__m128h A,
304 __m128h B) {
305 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GE_OS,
306 _MM_FROUND_CUR_DIRECTION);
307 }
308
309 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comineq_sh(__m128h A,
310 __m128h B) {
311 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_NEQ_US,
312 _MM_FROUND_CUR_DIRECTION);
313 }
314
315 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomieq_sh(__m128h A,
316 __m128h B) {
317 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_EQ_OQ,
318 _MM_FROUND_CUR_DIRECTION);
319 }
320
321 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomilt_sh(__m128h A,
322 __m128h B) {
323 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LT_OQ,
324 _MM_FROUND_CUR_DIRECTION);
325 }
326
327 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomile_sh(__m128h A,
328 __m128h B) {
329 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LE_OQ,
330 _MM_FROUND_CUR_DIRECTION);
331 }
332
333 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomigt_sh(__m128h A,
334 __m128h B) {
335 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GT_OQ,
336 _MM_FROUND_CUR_DIRECTION);
337 }
338
339 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomige_sh(__m128h A,
340 __m128h B) {
341 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GE_OQ,
342 _MM_FROUND_CUR_DIRECTION);
343 }
344
345 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomineq_sh(__m128h A,
346 __m128h B) {
347 return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_NEQ_UQ,
348 _MM_FROUND_CUR_DIRECTION);
349 }
350
351 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_add_ph(__m512h __A,
352 __m512h __B) {
353 return (__m512h)((__v32hf)__A + (__v32hf)__B);
354 }
355
356 static __inline__ __m512h __DEFAULT_FN_ATTRS512
357 _mm512_mask_add_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
358 return (__m512h)__builtin_ia32_selectph_512(
359 (__mmask32)__U, (__v32hf)_mm512_add_ph(__A, __B), (__v32hf)__W);
360 }
361
362 static __inline__ __m512h __DEFAULT_FN_ATTRS512
363 _mm512_maskz_add_ph(__mmask32 __U, __m512h __A, __m512h __B) {
364 return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
365 (__v32hf)_mm512_add_ph(__A, __B),
366 (__v32hf)_mm512_setzero_ph());
367 }
368
369 #define _mm512_add_round_ph(A, B, R) \
370 ((__m512h)__builtin_ia32_addph512((__v32hf)(__m512h)(A), \
371 (__v32hf)(__m512h)(B), (int)(R)))
372
373 #define _mm512_mask_add_round_ph(W, U, A, B, R) \
374 ((__m512h)__builtin_ia32_selectph_512( \
375 (__mmask32)(U), (__v32hf)_mm512_add_round_ph((A), (B), (R)), \
376 (__v32hf)(__m512h)(W)))
377
378 #define _mm512_maskz_add_round_ph(U, A, B, R) \
379 ((__m512h)__builtin_ia32_selectph_512( \
380 (__mmask32)(U), (__v32hf)_mm512_add_round_ph((A), (B), (R)), \
381 (__v32hf)_mm512_setzero_ph()))
382
383 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_sub_ph(__m512h __A,
384 __m512h __B) {
385 return (__m512h)((__v32hf)__A - (__v32hf)__B);
386 }
387
388 static __inline__ __m512h __DEFAULT_FN_ATTRS512
389 _mm512_mask_sub_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
390 return (__m512h)__builtin_ia32_selectph_512(
391 (__mmask32)__U, (__v32hf)_mm512_sub_ph(__A, __B), (__v32hf)__W);
392 }
393
394 static __inline__ __m512h __DEFAULT_FN_ATTRS512
395 _mm512_maskz_sub_ph(__mmask32 __U, __m512h __A, __m512h __B) {
396 return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
397 (__v32hf)_mm512_sub_ph(__A, __B),
398 (__v32hf)_mm512_setzero_ph());
399 }
400
401 #define _mm512_sub_round_ph(A, B, R) \
402 ((__m512h)__builtin_ia32_subph512((__v32hf)(__m512h)(A), \
403 (__v32hf)(__m512h)(B), (int)(R)))
404
405 #define _mm512_mask_sub_round_ph(W, U, A, B, R) \
406 ((__m512h)__builtin_ia32_selectph_512( \
407 (__mmask32)(U), (__v32hf)_mm512_sub_round_ph((A), (B), (R)), \
408 (__v32hf)(__m512h)(W)))
409
410 #define _mm512_maskz_sub_round_ph(U, A, B, R) \
411 ((__m512h)__builtin_ia32_selectph_512( \
412 (__mmask32)(U), (__v32hf)_mm512_sub_round_ph((A), (B), (R)), \
413 (__v32hf)_mm512_setzero_ph()))
414
415 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_mul_ph(__m512h __A,
416 __m512h __B) {
417 return (__m512h)((__v32hf)__A * (__v32hf)__B);
418 }
419
420 static __inline__ __m512h __DEFAULT_FN_ATTRS512
421 _mm512_mask_mul_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
422 return (__m512h)__builtin_ia32_selectph_512(
423 (__mmask32)__U, (__v32hf)_mm512_mul_ph(__A, __B), (__v32hf)__W);
424 }
425
426 static __inline__ __m512h __DEFAULT_FN_ATTRS512
427 _mm512_maskz_mul_ph(__mmask32 __U, __m512h __A, __m512h __B) {
428 return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
429 (__v32hf)_mm512_mul_ph(__A, __B),
430 (__v32hf)_mm512_setzero_ph());
431 }
432
433 #define _mm512_mul_round_ph(A, B, R) \
434 ((__m512h)__builtin_ia32_mulph512((__v32hf)(__m512h)(A), \
435 (__v32hf)(__m512h)(B), (int)(R)))
436
437 #define _mm512_mask_mul_round_ph(W, U, A, B, R) \
438 ((__m512h)__builtin_ia32_selectph_512( \
439 (__mmask32)(U), (__v32hf)_mm512_mul_round_ph((A), (B), (R)), \
440 (__v32hf)(__m512h)(W)))
441
442 #define _mm512_maskz_mul_round_ph(U, A, B, R) \
443 ((__m512h)__builtin_ia32_selectph_512( \
444 (__mmask32)(U), (__v32hf)_mm512_mul_round_ph((A), (B), (R)), \
445 (__v32hf)_mm512_setzero_ph()))
446
447 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_div_ph(__m512h __A,
448 __m512h __B) {
449 return (__m512h)((__v32hf)__A / (__v32hf)__B);
450 }
451
452 static __inline__ __m512h __DEFAULT_FN_ATTRS512
453 _mm512_mask_div_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
454 return (__m512h)__builtin_ia32_selectph_512(
455 (__mmask32)__U, (__v32hf)_mm512_div_ph(__A, __B), (__v32hf)__W);
456 }
457
458 static __inline__ __m512h __DEFAULT_FN_ATTRS512
459 _mm512_maskz_div_ph(__mmask32 __U, __m512h __A, __m512h __B) {
460 return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
461 (__v32hf)_mm512_div_ph(__A, __B),
462 (__v32hf)_mm512_setzero_ph());
463 }
464
465 #define _mm512_div_round_ph(A, B, R) \
466 ((__m512h)__builtin_ia32_divph512((__v32hf)(__m512h)(A), \
467 (__v32hf)(__m512h)(B), (int)(R)))
468
469 #define _mm512_mask_div_round_ph(W, U, A, B, R) \
470 ((__m512h)__builtin_ia32_selectph_512( \
471 (__mmask32)(U), (__v32hf)_mm512_div_round_ph((A), (B), (R)), \
472 (__v32hf)(__m512h)(W)))
473
474 #define _mm512_maskz_div_round_ph(U, A, B, R) \
475 ((__m512h)__builtin_ia32_selectph_512( \
476 (__mmask32)(U), (__v32hf)_mm512_div_round_ph((A), (B), (R)), \
477 (__v32hf)_mm512_setzero_ph()))
478
479 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_min_ph(__m512h __A,
480 __m512h __B) {
481 return (__m512h)__builtin_ia32_minph512((__v32hf)__A, (__v32hf)__B,
482 _MM_FROUND_CUR_DIRECTION);
483 }
484
485 static __inline__ __m512h __DEFAULT_FN_ATTRS512
486 _mm512_mask_min_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
487 return (__m512h)__builtin_ia32_selectph_512(
488 (__mmask32)__U, (__v32hf)_mm512_min_ph(__A, __B), (__v32hf)__W);
489 }
490
491 static __inline__ __m512h __DEFAULT_FN_ATTRS512
492 _mm512_maskz_min_ph(__mmask32 __U, __m512h __A, __m512h __B) {
493 return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
494 (__v32hf)_mm512_min_ph(__A, __B),
495 (__v32hf)_mm512_setzero_ph());
496 }
497
498 #define _mm512_min_round_ph(A, B, R) \
499 ((__m512h)__builtin_ia32_minph512((__v32hf)(__m512h)(A), \
500 (__v32hf)(__m512h)(B), (int)(R)))
501
502 #define _mm512_mask_min_round_ph(W, U, A, B, R) \
503 ((__m512h)__builtin_ia32_selectph_512( \
504 (__mmask32)(U), (__v32hf)_mm512_min_round_ph((A), (B), (R)), \
505 (__v32hf)(__m512h)(W)))
506
507 #define _mm512_maskz_min_round_ph(U, A, B, R) \
508 ((__m512h)__builtin_ia32_selectph_512( \
509 (__mmask32)(U), (__v32hf)_mm512_min_round_ph((A), (B), (R)), \
510 (__v32hf)_mm512_setzero_ph()))
511
512 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_max_ph(__m512h __A,
513 __m512h __B) {
514 return (__m512h)__builtin_ia32_maxph512((__v32hf)__A, (__v32hf)__B,
515 _MM_FROUND_CUR_DIRECTION);
516 }
517
518 static __inline__ __m512h __DEFAULT_FN_ATTRS512
519 _mm512_mask_max_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
520 return (__m512h)__builtin_ia32_selectph_512(
521 (__mmask32)__U, (__v32hf)_mm512_max_ph(__A, __B), (__v32hf)__W);
522 }
523
524 static __inline__ __m512h __DEFAULT_FN_ATTRS512
525 _mm512_maskz_max_ph(__mmask32 __U, __m512h __A, __m512h __B) {
526 return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
527 (__v32hf)_mm512_max_ph(__A, __B),
528 (__v32hf)_mm512_setzero_ph());
529 }
530
531 #define _mm512_max_round_ph(A, B, R) \
532 ((__m512h)__builtin_ia32_maxph512((__v32hf)(__m512h)(A), \
533 (__v32hf)(__m512h)(B), (int)(R)))
534
535 #define _mm512_mask_max_round_ph(W, U, A, B, R) \
536 ((__m512h)__builtin_ia32_selectph_512( \
537 (__mmask32)(U), (__v32hf)_mm512_max_round_ph((A), (B), (R)), \
538 (__v32hf)(__m512h)(W)))
539
540 #define _mm512_maskz_max_round_ph(U, A, B, R) \
541 ((__m512h)__builtin_ia32_selectph_512( \
542 (__mmask32)(U), (__v32hf)_mm512_max_round_ph((A), (B), (R)), \
543 (__v32hf)_mm512_setzero_ph()))
544
545 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_abs_ph(__m512h __A) {
546 return (__m512h)_mm512_and_epi32(_mm512_set1_epi32(0x7FFF7FFF), (__m512i)__A);
547 }
548
549 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_conj_pch(__m512h __A) {
550 return (__m512h)_mm512_xor_ps((__m512)__A, _mm512_set1_ps(-0.0f));
551 }
552
553 static __inline__ __m512h __DEFAULT_FN_ATTRS512
554 _mm512_mask_conj_pch(__m512h __W, __mmask16 __U, __m512h __A) {
555 return (__m512h)__builtin_ia32_selectps_512(
556 (__mmask16)__U, (__v16sf)_mm512_conj_pch(__A), (__v16sf)__W);
557 }
558
559 static __inline__ __m512h __DEFAULT_FN_ATTRS512
560 _mm512_maskz_conj_pch(__mmask16 __U, __m512h __A) {
561 return (__m512h)__builtin_ia32_selectps_512((__mmask16)__U,
562 (__v16sf)_mm512_conj_pch(__A),
563 (__v16sf)_mm512_setzero_ps());
564 }
565
566 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_add_sh(__m128h __A,
567 __m128h __B) {
568 __A[0] += __B[0];
569 return __A;
570 }
571
572 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_add_sh(__m128h __W,
573 __mmask8 __U,
574 __m128h __A,
575 __m128h __B) {
576 __A = _mm_add_sh(__A, __B);
577 return __builtin_ia32_selectsh_128(__U, __A, __W);
578 }
579
580 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_add_sh(__mmask8 __U,
581 __m128h __A,
582 __m128h __B) {
583 __A = _mm_add_sh(__A, __B);
584 return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
585 }
586
587 #define _mm_add_round_sh(A, B, R) \
588 ((__m128h)__builtin_ia32_addsh_round_mask( \
589 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
590 (__mmask8)-1, (int)(R)))
591
592 #define _mm_mask_add_round_sh(W, U, A, B, R) \
593 ((__m128h)__builtin_ia32_addsh_round_mask( \
594 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
595 (__mmask8)(U), (int)(R)))
596
597 #define _mm_maskz_add_round_sh(U, A, B, R) \
598 ((__m128h)__builtin_ia32_addsh_round_mask( \
599 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
600 (__mmask8)(U), (int)(R)))
601
602 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_sub_sh(__m128h __A,
603 __m128h __B) {
604 __A[0] -= __B[0];
605 return __A;
606 }
607
608 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_sub_sh(__m128h __W,
609 __mmask8 __U,
610 __m128h __A,
611 __m128h __B) {
612 __A = _mm_sub_sh(__A, __B);
613 return __builtin_ia32_selectsh_128(__U, __A, __W);
614 }
615
616 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_sub_sh(__mmask8 __U,
617 __m128h __A,
618 __m128h __B) {
619 __A = _mm_sub_sh(__A, __B);
620 return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
621 }
622
623 #define _mm_sub_round_sh(A, B, R) \
624 ((__m128h)__builtin_ia32_subsh_round_mask( \
625 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
626 (__mmask8)-1, (int)(R)))
627
628 #define _mm_mask_sub_round_sh(W, U, A, B, R) \
629 ((__m128h)__builtin_ia32_subsh_round_mask( \
630 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
631 (__mmask8)(U), (int)(R)))
632
633 #define _mm_maskz_sub_round_sh(U, A, B, R) \
634 ((__m128h)__builtin_ia32_subsh_round_mask( \
635 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
636 (__mmask8)(U), (int)(R)))
637
638 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mul_sh(__m128h __A,
639 __m128h __B) {
640 __A[0] *= __B[0];
641 return __A;
642 }
643
644 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_mul_sh(__m128h __W,
645 __mmask8 __U,
646 __m128h __A,
647 __m128h __B) {
648 __A = _mm_mul_sh(__A, __B);
649 return __builtin_ia32_selectsh_128(__U, __A, __W);
650 }
651
652 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_mul_sh(__mmask8 __U,
653 __m128h __A,
654 __m128h __B) {
655 __A = _mm_mul_sh(__A, __B);
656 return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
657 }
658
659 #define _mm_mul_round_sh(A, B, R) \
660 ((__m128h)__builtin_ia32_mulsh_round_mask( \
661 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
662 (__mmask8)-1, (int)(R)))
663
664 #define _mm_mask_mul_round_sh(W, U, A, B, R) \
665 ((__m128h)__builtin_ia32_mulsh_round_mask( \
666 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
667 (__mmask8)(U), (int)(R)))
668
669 #define _mm_maskz_mul_round_sh(U, A, B, R) \
670 ((__m128h)__builtin_ia32_mulsh_round_mask( \
671 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
672 (__mmask8)(U), (int)(R)))
673
674 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_div_sh(__m128h __A,
675 __m128h __B) {
676 __A[0] /= __B[0];
677 return __A;
678 }
679
680 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_div_sh(__m128h __W,
681 __mmask8 __U,
682 __m128h __A,
683 __m128h __B) {
684 __A = _mm_div_sh(__A, __B);
685 return __builtin_ia32_selectsh_128(__U, __A, __W);
686 }
687
688 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_div_sh(__mmask8 __U,
689 __m128h __A,
690 __m128h __B) {
691 __A = _mm_div_sh(__A, __B);
692 return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
693 }
694
695 #define _mm_div_round_sh(A, B, R) \
696 ((__m128h)__builtin_ia32_divsh_round_mask( \
697 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
698 (__mmask8)-1, (int)(R)))
699
700 #define _mm_mask_div_round_sh(W, U, A, B, R) \
701 ((__m128h)__builtin_ia32_divsh_round_mask( \
702 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
703 (__mmask8)(U), (int)(R)))
704
705 #define _mm_maskz_div_round_sh(U, A, B, R) \
706 ((__m128h)__builtin_ia32_divsh_round_mask( \
707 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
708 (__mmask8)(U), (int)(R)))
709
710 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_min_sh(__m128h __A,
711 __m128h __B) {
712 return (__m128h)__builtin_ia32_minsh_round_mask(
713 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
714 _MM_FROUND_CUR_DIRECTION);
715 }
716
717 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_min_sh(__m128h __W,
718 __mmask8 __U,
719 __m128h __A,
720 __m128h __B) {
721 return (__m128h)__builtin_ia32_minsh_round_mask((__v8hf)__A, (__v8hf)__B,
722 (__v8hf)__W, (__mmask8)__U,
723 _MM_FROUND_CUR_DIRECTION);
724 }
725
726 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_min_sh(__mmask8 __U,
727 __m128h __A,
728 __m128h __B) {
729 return (__m128h)__builtin_ia32_minsh_round_mask(
730 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
731 _MM_FROUND_CUR_DIRECTION);
732 }
733
734 #define _mm_min_round_sh(A, B, R) \
735 ((__m128h)__builtin_ia32_minsh_round_mask( \
736 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
737 (__mmask8)-1, (int)(R)))
738
739 #define _mm_mask_min_round_sh(W, U, A, B, R) \
740 ((__m128h)__builtin_ia32_minsh_round_mask( \
741 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
742 (__mmask8)(U), (int)(R)))
743
744 #define _mm_maskz_min_round_sh(U, A, B, R) \
745 ((__m128h)__builtin_ia32_minsh_round_mask( \
746 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
747 (__mmask8)(U), (int)(R)))
748
749 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_max_sh(__m128h __A,
750 __m128h __B) {
751 return (__m128h)__builtin_ia32_maxsh_round_mask(
752 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
753 _MM_FROUND_CUR_DIRECTION);
754 }
755
756 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_max_sh(__m128h __W,
757 __mmask8 __U,
758 __m128h __A,
759 __m128h __B) {
760 return (__m128h)__builtin_ia32_maxsh_round_mask((__v8hf)__A, (__v8hf)__B,
761 (__v8hf)__W, (__mmask8)__U,
762 _MM_FROUND_CUR_DIRECTION);
763 }
764
765 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_max_sh(__mmask8 __U,
766 __m128h __A,
767 __m128h __B) {
768 return (__m128h)__builtin_ia32_maxsh_round_mask(
769 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
770 _MM_FROUND_CUR_DIRECTION);
771 }
772
773 #define _mm_max_round_sh(A, B, R) \
774 ((__m128h)__builtin_ia32_maxsh_round_mask( \
775 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
776 (__mmask8)-1, (int)(R)))
777
778 #define _mm_mask_max_round_sh(W, U, A, B, R) \
779 ((__m128h)__builtin_ia32_maxsh_round_mask( \
780 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
781 (__mmask8)(U), (int)(R)))
782
783 #define _mm_maskz_max_round_sh(U, A, B, R) \
784 ((__m128h)__builtin_ia32_maxsh_round_mask( \
785 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
786 (__mmask8)(U), (int)(R)))
787
788 #define _mm512_cmp_round_ph_mask(A, B, P, R) \
789 ((__mmask32)__builtin_ia32_cmpph512_mask((__v32hf)(__m512h)(A), \
790 (__v32hf)(__m512h)(B), (int)(P), \
791 (__mmask32)-1, (int)(R)))
792
793 #define _mm512_mask_cmp_round_ph_mask(U, A, B, P, R) \
794 ((__mmask32)__builtin_ia32_cmpph512_mask((__v32hf)(__m512h)(A), \
795 (__v32hf)(__m512h)(B), (int)(P), \
796 (__mmask32)(U), (int)(R)))
797
798 #define _mm512_cmp_ph_mask(A, B, P) \
799 _mm512_cmp_round_ph_mask((A), (B), (P), _MM_FROUND_CUR_DIRECTION)
800
801 #define _mm512_mask_cmp_ph_mask(U, A, B, P) \
802 _mm512_mask_cmp_round_ph_mask((U), (A), (B), (P), _MM_FROUND_CUR_DIRECTION)
803
804 #define _mm_cmp_round_sh_mask(X, Y, P, R) \
805 ((__mmask8)__builtin_ia32_cmpsh_mask((__v8hf)(__m128h)(X), \
806 (__v8hf)(__m128h)(Y), (int)(P), \
807 (__mmask8)-1, (int)(R)))
808
809 #define _mm_mask_cmp_round_sh_mask(M, X, Y, P, R) \
810 ((__mmask8)__builtin_ia32_cmpsh_mask((__v8hf)(__m128h)(X), \
811 (__v8hf)(__m128h)(Y), (int)(P), \
812 (__mmask8)(M), (int)(R)))
813
814 #define _mm_cmp_sh_mask(X, Y, P) \
815 ((__mmask8)__builtin_ia32_cmpsh_mask( \
816 (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(P), (__mmask8)-1, \
817 _MM_FROUND_CUR_DIRECTION))
818
819 #define _mm_mask_cmp_sh_mask(M, X, Y, P) \
820 ((__mmask8)__builtin_ia32_cmpsh_mask( \
821 (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(P), (__mmask8)(M), \
822 _MM_FROUND_CUR_DIRECTION))
823 // loads with vmovsh:
824 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_load_sh(void const *__dp) {
825 struct __mm_load_sh_struct {
826 _Float16 __u;
827 } __attribute__((__packed__, __may_alias__));
828 _Float16 __u = ((const struct __mm_load_sh_struct *)__dp)->__u;
829 return (__m128h){__u, 0, 0, 0, 0, 0, 0, 0};
830 }
831
832 static __inline__ __m128h __DEFAULT_FN_ATTRS128
833 _mm_mask_load_sh(__m128h __W, __mmask8 __U, const void *__A) {
834 __m128h src = (__v8hf)__builtin_shufflevector(
835 (__v8hf)__W, (__v8hf)_mm_setzero_ph(), 0, 8, 8, 8, 8, 8, 8, 8);
836
837 return (__m128h)__builtin_ia32_loadsh128_mask((const __v8hf *)__A, src, __U & 1);
838 }
839
840 static __inline__ __m128h __DEFAULT_FN_ATTRS128
841 _mm_maskz_load_sh(__mmask8 __U, const void *__A) {
842 return (__m128h)__builtin_ia32_loadsh128_mask(
843 (const __v8hf *)__A, (__v8hf)_mm_setzero_ph(), __U & 1);
844 }
845
846 static __inline__ __m512h __DEFAULT_FN_ATTRS512
847 _mm512_load_ph(void const *__p) {
848 return *(const __m512h *)__p;
849 }
850
851 static __inline__ __m256h __DEFAULT_FN_ATTRS256
852 _mm256_load_ph(void const *__p) {
853 return *(const __m256h *)__p;
854 }
855
856 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_load_ph(void const *__p) {
857 return *(const __m128h *)__p;
858 }
859
860 static __inline__ __m512h __DEFAULT_FN_ATTRS512
861 _mm512_loadu_ph(void const *__p) {
862 struct __loadu_ph {
863 __m512h_u __v;
864 } __attribute__((__packed__, __may_alias__));
865 return ((const struct __loadu_ph *)__p)->__v;
866 }
867
868 static __inline__ __m256h __DEFAULT_FN_ATTRS256
869 _mm256_loadu_ph(void const *__p) {
870 struct __loadu_ph {
871 __m256h_u __v;
872 } __attribute__((__packed__, __may_alias__));
873 return ((const struct __loadu_ph *)__p)->__v;
874 }
875
876 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_loadu_ph(void const *__p) {
877 struct __loadu_ph {
878 __m128h_u __v;
879 } __attribute__((__packed__, __may_alias__));
880 return ((const struct __loadu_ph *)__p)->__v;
881 }
882
883 // stores with vmovsh:
884 static __inline__ void __DEFAULT_FN_ATTRS128 _mm_store_sh(void *__dp,
885 __m128h __a) {
886 struct __mm_store_sh_struct {
887 _Float16 __u;
888 } __attribute__((__packed__, __may_alias__));
889 ((struct __mm_store_sh_struct *)__dp)->__u = __a[0];
890 }
891
892 static __inline__ void __DEFAULT_FN_ATTRS128 _mm_mask_store_sh(void *__W,
893 __mmask8 __U,
894 __m128h __A) {
895 __builtin_ia32_storesh128_mask((__v8hf *)__W, __A, __U & 1);
896 }
897
898 static __inline__ void __DEFAULT_FN_ATTRS512 _mm512_store_ph(void *__P,
899 __m512h __A) {
900 *(__m512h *)__P = __A;
901 }
902
903 static __inline__ void __DEFAULT_FN_ATTRS256 _mm256_store_ph(void *__P,
904 __m256h __A) {
905 *(__m256h *)__P = __A;
906 }
907
908 static __inline__ void __DEFAULT_FN_ATTRS128 _mm_store_ph(void *__P,
909 __m128h __A) {
910 *(__m128h *)__P = __A;
911 }
912
913 static __inline__ void __DEFAULT_FN_ATTRS512 _mm512_storeu_ph(void *__P,
914 __m512h __A) {
915 struct __storeu_ph {
916 __m512h_u __v;
917 } __attribute__((__packed__, __may_alias__));
918 ((struct __storeu_ph *)__P)->__v = __A;
919 }
920
921 static __inline__ void __DEFAULT_FN_ATTRS256 _mm256_storeu_ph(void *__P,
922 __m256h __A) {
923 struct __storeu_ph {
924 __m256h_u __v;
925 } __attribute__((__packed__, __may_alias__));
926 ((struct __storeu_ph *)__P)->__v = __A;
927 }
928
929 static __inline__ void __DEFAULT_FN_ATTRS128 _mm_storeu_ph(void *__P,
930 __m128h __A) {
931 struct __storeu_ph {
932 __m128h_u __v;
933 } __attribute__((__packed__, __may_alias__));
934 ((struct __storeu_ph *)__P)->__v = __A;
935 }
936
937 // moves with vmovsh:
938 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_move_sh(__m128h __a,
939 __m128h __b) {
940 __a[0] = __b[0];
941 return __a;
942 }
943
944 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_move_sh(__m128h __W,
945 __mmask8 __U,
946 __m128h __A,
947 __m128h __B) {
948 return __builtin_ia32_selectsh_128(__U, _mm_move_sh(__A, __B), __W);
949 }
950
951 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_move_sh(__mmask8 __U,
952 __m128h __A,
953 __m128h __B) {
954 return __builtin_ia32_selectsh_128(__U, _mm_move_sh(__A, __B),
955 _mm_setzero_ph());
956 }
957
958 // vmovw:
959 static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtsi16_si128(short __a) {
960 return (__m128i)(__v8hi){__a, 0, 0, 0, 0, 0, 0, 0};
961 }
962
963 static __inline__ short __DEFAULT_FN_ATTRS128 _mm_cvtsi128_si16(__m128i __a) {
964 __v8hi __b = (__v8hi)__a;
965 return __b[0];
966 }
967
968 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_rcp_ph(__m512h __A) {
969 return (__m512h)__builtin_ia32_rcpph512_mask(
970 (__v32hf)__A, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1);
971 }
972
973 static __inline__ __m512h __DEFAULT_FN_ATTRS512
974 _mm512_mask_rcp_ph(__m512h __W, __mmask32 __U, __m512h __A) {
975 return (__m512h)__builtin_ia32_rcpph512_mask((__v32hf)__A, (__v32hf)__W,
976 (__mmask32)__U);
977 }
978
979 static __inline__ __m512h __DEFAULT_FN_ATTRS512
980 _mm512_maskz_rcp_ph(__mmask32 __U, __m512h __A) {
981 return (__m512h)__builtin_ia32_rcpph512_mask(
982 (__v32hf)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U);
983 }
984
985 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_rsqrt_ph(__m512h __A) {
986 return (__m512h)__builtin_ia32_rsqrtph512_mask(
987 (__v32hf)__A, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1);
988 }
989
990 static __inline__ __m512h __DEFAULT_FN_ATTRS512
991 _mm512_mask_rsqrt_ph(__m512h __W, __mmask32 __U, __m512h __A) {
992 return (__m512h)__builtin_ia32_rsqrtph512_mask((__v32hf)__A, (__v32hf)__W,
993 (__mmask32)__U);
994 }
995
996 static __inline__ __m512h __DEFAULT_FN_ATTRS512
997 _mm512_maskz_rsqrt_ph(__mmask32 __U, __m512h __A) {
998 return (__m512h)__builtin_ia32_rsqrtph512_mask(
999 (__v32hf)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U);
1000 }
1001
1002 #define _mm512_getmant_ph(A, B, C) \
1003 ((__m512h)__builtin_ia32_getmantph512_mask( \
1004 (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), \
1005 (__v32hf)_mm512_undefined_ph(), (__mmask32)-1, \
1006 _MM_FROUND_CUR_DIRECTION))
1007
1008 #define _mm512_mask_getmant_ph(W, U, A, B, C) \
1009 ((__m512h)__builtin_ia32_getmantph512_mask( \
1010 (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), (__v32hf)(__m512h)(W), \
1011 (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
1012
1013 #define _mm512_maskz_getmant_ph(U, A, B, C) \
1014 ((__m512h)__builtin_ia32_getmantph512_mask( \
1015 (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), \
1016 (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
1017
1018 #define _mm512_getmant_round_ph(A, B, C, R) \
1019 ((__m512h)__builtin_ia32_getmantph512_mask( \
1020 (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), \
1021 (__v32hf)_mm512_undefined_ph(), (__mmask32)-1, (int)(R)))
1022
1023 #define _mm512_mask_getmant_round_ph(W, U, A, B, C, R) \
1024 ((__m512h)__builtin_ia32_getmantph512_mask( \
1025 (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), (__v32hf)(__m512h)(W), \
1026 (__mmask32)(U), (int)(R)))
1027
1028 #define _mm512_maskz_getmant_round_ph(U, A, B, C, R) \
1029 ((__m512h)__builtin_ia32_getmantph512_mask( \
1030 (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), \
1031 (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
1032
1033 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_getexp_ph(__m512h __A) {
1034 return (__m512h)__builtin_ia32_getexpph512_mask(
1035 (__v32hf)__A, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1,
1036 _MM_FROUND_CUR_DIRECTION);
1037 }
1038
1039 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1040 _mm512_mask_getexp_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1041 return (__m512h)__builtin_ia32_getexpph512_mask(
1042 (__v32hf)__A, (__v32hf)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
1043 }
1044
1045 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1046 _mm512_maskz_getexp_ph(__mmask32 __U, __m512h __A) {
1047 return (__m512h)__builtin_ia32_getexpph512_mask(
1048 (__v32hf)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
1049 _MM_FROUND_CUR_DIRECTION);
1050 }
1051
1052 #define _mm512_getexp_round_ph(A, R) \
1053 ((__m512h)__builtin_ia32_getexpph512_mask((__v32hf)(__m512h)(A), \
1054 (__v32hf)_mm512_undefined_ph(), \
1055 (__mmask32)-1, (int)(R)))
1056
1057 #define _mm512_mask_getexp_round_ph(W, U, A, R) \
1058 ((__m512h)__builtin_ia32_getexpph512_mask( \
1059 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(W), (__mmask32)(U), (int)(R)))
1060
1061 #define _mm512_maskz_getexp_round_ph(U, A, R) \
1062 ((__m512h)__builtin_ia32_getexpph512_mask((__v32hf)(__m512h)(A), \
1063 (__v32hf)_mm512_setzero_ph(), \
1064 (__mmask32)(U), (int)(R)))
1065
1066 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_scalef_ph(__m512h __A,
1067 __m512h __B) {
1068 return (__m512h)__builtin_ia32_scalefph512_mask(
1069 (__v32hf)__A, (__v32hf)__B, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1,
1070 _MM_FROUND_CUR_DIRECTION);
1071 }
1072
1073 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1074 _mm512_mask_scalef_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
1075 return (__m512h)__builtin_ia32_scalefph512_mask((__v32hf)__A, (__v32hf)__B,
1076 (__v32hf)__W, (__mmask32)__U,
1077 _MM_FROUND_CUR_DIRECTION);
1078 }
1079
1080 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1081 _mm512_maskz_scalef_ph(__mmask32 __U, __m512h __A, __m512h __B) {
1082 return (__m512h)__builtin_ia32_scalefph512_mask(
1083 (__v32hf)__A, (__v32hf)__B, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
1084 _MM_FROUND_CUR_DIRECTION);
1085 }
1086
1087 #define _mm512_scalef_round_ph(A, B, R) \
1088 ((__m512h)__builtin_ia32_scalefph512_mask( \
1089 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), \
1090 (__v32hf)_mm512_undefined_ph(), (__mmask32)-1, (int)(R)))
1091
1092 #define _mm512_mask_scalef_round_ph(W, U, A, B, R) \
1093 ((__m512h)__builtin_ia32_scalefph512_mask( \
1094 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(W), \
1095 (__mmask32)(U), (int)(R)))
1096
1097 #define _mm512_maskz_scalef_round_ph(U, A, B, R) \
1098 ((__m512h)__builtin_ia32_scalefph512_mask( \
1099 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), \
1100 (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
1101
1102 #define _mm512_roundscale_ph(A, B) \
1103 ((__m512h)__builtin_ia32_rndscaleph_mask( \
1104 (__v32hf)(__m512h)(A), (int)(B), (__v32hf)(__m512h)(A), (__mmask32)-1, \
1105 _MM_FROUND_CUR_DIRECTION))
1106
1107 #define _mm512_mask_roundscale_ph(A, B, C, imm) \
1108 ((__m512h)__builtin_ia32_rndscaleph_mask( \
1109 (__v32hf)(__m512h)(C), (int)(imm), (__v32hf)(__m512h)(A), \
1110 (__mmask32)(B), _MM_FROUND_CUR_DIRECTION))
1111
1112 #define _mm512_maskz_roundscale_ph(A, B, imm) \
1113 ((__m512h)__builtin_ia32_rndscaleph_mask( \
1114 (__v32hf)(__m512h)(B), (int)(imm), (__v32hf)_mm512_setzero_ph(), \
1115 (__mmask32)(A), _MM_FROUND_CUR_DIRECTION))
1116
1117 #define _mm512_mask_roundscale_round_ph(A, B, C, imm, R) \
1118 ((__m512h)__builtin_ia32_rndscaleph_mask((__v32hf)(__m512h)(C), (int)(imm), \
1119 (__v32hf)(__m512h)(A), \
1120 (__mmask32)(B), (int)(R)))
1121
1122 #define _mm512_maskz_roundscale_round_ph(A, B, imm, R) \
1123 ((__m512h)__builtin_ia32_rndscaleph_mask((__v32hf)(__m512h)(B), (int)(imm), \
1124 (__v32hf)_mm512_setzero_ph(), \
1125 (__mmask32)(A), (int)(R)))
1126
1127 #define _mm512_roundscale_round_ph(A, imm, R) \
1128 ((__m512h)__builtin_ia32_rndscaleph_mask((__v32hf)(__m512h)(A), (int)(imm), \
1129 (__v32hf)_mm512_undefined_ph(), \
1130 (__mmask32)-1, (int)(R)))
1131
1132 #define _mm512_reduce_ph(A, imm) \
1133 ((__m512h)__builtin_ia32_reduceph512_mask( \
1134 (__v32hf)(__m512h)(A), (int)(imm), (__v32hf)_mm512_undefined_ph(), \
1135 (__mmask32)-1, _MM_FROUND_CUR_DIRECTION))
1136
1137 #define _mm512_mask_reduce_ph(W, U, A, imm) \
1138 ((__m512h)__builtin_ia32_reduceph512_mask( \
1139 (__v32hf)(__m512h)(A), (int)(imm), (__v32hf)(__m512h)(W), \
1140 (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
1141
1142 #define _mm512_maskz_reduce_ph(U, A, imm) \
1143 ((__m512h)__builtin_ia32_reduceph512_mask( \
1144 (__v32hf)(__m512h)(A), (int)(imm), (__v32hf)_mm512_setzero_ph(), \
1145 (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
1146
1147 #define _mm512_mask_reduce_round_ph(W, U, A, imm, R) \
1148 ((__m512h)__builtin_ia32_reduceph512_mask((__v32hf)(__m512h)(A), (int)(imm), \
1149 (__v32hf)(__m512h)(W), \
1150 (__mmask32)(U), (int)(R)))
1151
1152 #define _mm512_maskz_reduce_round_ph(U, A, imm, R) \
1153 ((__m512h)__builtin_ia32_reduceph512_mask((__v32hf)(__m512h)(A), (int)(imm), \
1154 (__v32hf)_mm512_setzero_ph(), \
1155 (__mmask32)(U), (int)(R)))
1156
1157 #define _mm512_reduce_round_ph(A, imm, R) \
1158 ((__m512h)__builtin_ia32_reduceph512_mask((__v32hf)(__m512h)(A), (int)(imm), \
1159 (__v32hf)_mm512_undefined_ph(), \
1160 (__mmask32)-1, (int)(R)))
1161
1162 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_rcp_sh(__m128h __A,
1163 __m128h __B) {
1164 return (__m128h)__builtin_ia32_rcpsh_mask(
1165 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1);
1166 }
1167
1168 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_rcp_sh(__m128h __W,
1169 __mmask8 __U,
1170 __m128h __A,
1171 __m128h __B) {
1172 return (__m128h)__builtin_ia32_rcpsh_mask((__v8hf)__A, (__v8hf)__B,
1173 (__v8hf)__W, (__mmask8)__U);
1174 }
1175
1176 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_rcp_sh(__mmask8 __U,
1177 __m128h __A,
1178 __m128h __B) {
1179 return (__m128h)__builtin_ia32_rcpsh_mask(
1180 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
1181 }
1182
1183 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_rsqrt_sh(__m128h __A,
1184 __m128h __B) {
1185 return (__m128h)__builtin_ia32_rsqrtsh_mask(
1186 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1);
1187 }
1188
1189 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_rsqrt_sh(__m128h __W,
1190 __mmask8 __U,
1191 __m128h __A,
1192 __m128h __B) {
1193 return (__m128h)__builtin_ia32_rsqrtsh_mask((__v8hf)__A, (__v8hf)__B,
1194 (__v8hf)__W, (__mmask8)__U);
1195 }
1196
1197 static __inline__ __m128h __DEFAULT_FN_ATTRS128
1198 _mm_maskz_rsqrt_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1199 return (__m128h)__builtin_ia32_rsqrtsh_mask(
1200 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
1201 }
1202
1203 #define _mm_getmant_round_sh(A, B, C, D, R) \
1204 ((__m128h)__builtin_ia32_getmantsh_round_mask( \
1205 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)), \
1206 (__v8hf)_mm_setzero_ph(), (__mmask8)-1, (int)(R)))
1207
1208 #define _mm_getmant_sh(A, B, C, D) \
1209 ((__m128h)__builtin_ia32_getmantsh_round_mask( \
1210 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)), \
1211 (__v8hf)_mm_setzero_ph(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
1212
1213 #define _mm_mask_getmant_sh(W, U, A, B, C, D) \
1214 ((__m128h)__builtin_ia32_getmantsh_round_mask( \
1215 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)), \
1216 (__v8hf)(__m128h)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
1217
1218 #define _mm_mask_getmant_round_sh(W, U, A, B, C, D, R) \
1219 ((__m128h)__builtin_ia32_getmantsh_round_mask( \
1220 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)), \
1221 (__v8hf)(__m128h)(W), (__mmask8)(U), (int)(R)))
1222
1223 #define _mm_maskz_getmant_sh(U, A, B, C, D) \
1224 ((__m128h)__builtin_ia32_getmantsh_round_mask( \
1225 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)), \
1226 (__v8hf)_mm_setzero_ph(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
1227
1228 #define _mm_maskz_getmant_round_sh(U, A, B, C, D, R) \
1229 ((__m128h)__builtin_ia32_getmantsh_round_mask( \
1230 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)), \
1231 (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
1232
1233 #define _mm_getexp_round_sh(A, B, R) \
1234 ((__m128h)__builtin_ia32_getexpsh128_round_mask( \
1235 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1236 (__mmask8)-1, (int)(R)))
1237
1238 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_getexp_sh(__m128h __A,
1239 __m128h __B) {
1240 return (__m128h)__builtin_ia32_getexpsh128_round_mask(
1241 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
1242 _MM_FROUND_CUR_DIRECTION);
1243 }
1244
1245 static __inline__ __m128h __DEFAULT_FN_ATTRS128
1246 _mm_mask_getexp_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1247 return (__m128h)__builtin_ia32_getexpsh128_round_mask(
1248 (__v8hf)__A, (__v8hf)__B, (__v8hf)__W, (__mmask8)__U,
1249 _MM_FROUND_CUR_DIRECTION);
1250 }
1251
1252 #define _mm_mask_getexp_round_sh(W, U, A, B, R) \
1253 ((__m128h)__builtin_ia32_getexpsh128_round_mask( \
1254 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
1255 (__mmask8)(U), (int)(R)))
1256
1257 static __inline__ __m128h __DEFAULT_FN_ATTRS128
1258 _mm_maskz_getexp_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1259 return (__m128h)__builtin_ia32_getexpsh128_round_mask(
1260 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
1261 _MM_FROUND_CUR_DIRECTION);
1262 }
1263
1264 #define _mm_maskz_getexp_round_sh(U, A, B, R) \
1265 ((__m128h)__builtin_ia32_getexpsh128_round_mask( \
1266 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1267 (__mmask8)(U), (int)(R)))
1268
1269 #define _mm_scalef_round_sh(A, B, R) \
1270 ((__m128h)__builtin_ia32_scalefsh_round_mask( \
1271 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1272 (__mmask8)-1, (int)(R)))
1273
1274 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_scalef_sh(__m128h __A,
1275 __m128h __B) {
1276 return (__m128h)__builtin_ia32_scalefsh_round_mask(
1277 (__v8hf)__A, (__v8hf)(__B), (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
1278 _MM_FROUND_CUR_DIRECTION);
1279 }
1280
1281 static __inline__ __m128h __DEFAULT_FN_ATTRS128
1282 _mm_mask_scalef_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
1283 return (__m128h)__builtin_ia32_scalefsh_round_mask((__v8hf)__A, (__v8hf)__B,
1284 (__v8hf)__W, (__mmask8)__U,
1285 _MM_FROUND_CUR_DIRECTION);
1286 }
1287
1288 #define _mm_mask_scalef_round_sh(W, U, A, B, R) \
1289 ((__m128h)__builtin_ia32_scalefsh_round_mask( \
1290 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
1291 (__mmask8)(U), (int)(R)))
1292
1293 static __inline__ __m128h __DEFAULT_FN_ATTRS128
1294 _mm_maskz_scalef_sh(__mmask8 __U, __m128h __A, __m128h __B) {
1295 return (__m128h)__builtin_ia32_scalefsh_round_mask(
1296 (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
1297 _MM_FROUND_CUR_DIRECTION);
1298 }
1299
1300 #define _mm_maskz_scalef_round_sh(U, A, B, R) \
1301 ((__m128h)__builtin_ia32_scalefsh_round_mask( \
1302 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1303 (__mmask8)(U), (int)(R)))
1304
1305 #define _mm_roundscale_round_sh(A, B, imm, R) \
1306 ((__m128h)__builtin_ia32_rndscalesh_round_mask( \
1307 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1308 (__mmask8)-1, (int)(imm), (int)(R)))
1309
1310 #define _mm_roundscale_sh(A, B, imm) \
1311 ((__m128h)__builtin_ia32_rndscalesh_round_mask( \
1312 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1313 (__mmask8)-1, (int)(imm), _MM_FROUND_CUR_DIRECTION))
1314
1315 #define _mm_mask_roundscale_sh(W, U, A, B, I) \
1316 ((__m128h)__builtin_ia32_rndscalesh_round_mask( \
1317 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
1318 (__mmask8)(U), (int)(I), _MM_FROUND_CUR_DIRECTION))
1319
1320 #define _mm_mask_roundscale_round_sh(W, U, A, B, I, R) \
1321 ((__m128h)__builtin_ia32_rndscalesh_round_mask( \
1322 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
1323 (__mmask8)(U), (int)(I), (int)(R)))
1324
1325 #define _mm_maskz_roundscale_sh(U, A, B, I) \
1326 ((__m128h)__builtin_ia32_rndscalesh_round_mask( \
1327 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1328 (__mmask8)(U), (int)(I), _MM_FROUND_CUR_DIRECTION))
1329
1330 #define _mm_maskz_roundscale_round_sh(U, A, B, I, R) \
1331 ((__m128h)__builtin_ia32_rndscalesh_round_mask( \
1332 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1333 (__mmask8)(U), (int)(I), (int)(R)))
1334
1335 #define _mm_reduce_sh(A, B, C) \
1336 ((__m128h)__builtin_ia32_reducesh_mask( \
1337 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1338 (__mmask8)-1, (int)(C), _MM_FROUND_CUR_DIRECTION))
1339
1340 #define _mm_mask_reduce_sh(W, U, A, B, C) \
1341 ((__m128h)__builtin_ia32_reducesh_mask( \
1342 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
1343 (__mmask8)(U), (int)(C), _MM_FROUND_CUR_DIRECTION))
1344
1345 #define _mm_maskz_reduce_sh(U, A, B, C) \
1346 ((__m128h)__builtin_ia32_reducesh_mask( \
1347 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1348 (__mmask8)(U), (int)(C), _MM_FROUND_CUR_DIRECTION))
1349
1350 #define _mm_reduce_round_sh(A, B, C, R) \
1351 ((__m128h)__builtin_ia32_reducesh_mask( \
1352 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1353 (__mmask8)-1, (int)(C), (int)(R)))
1354
1355 #define _mm_mask_reduce_round_sh(W, U, A, B, C, R) \
1356 ((__m128h)__builtin_ia32_reducesh_mask( \
1357 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
1358 (__mmask8)(U), (int)(C), (int)(R)))
1359
1360 #define _mm_maskz_reduce_round_sh(U, A, B, C, R) \
1361 ((__m128h)__builtin_ia32_reducesh_mask( \
1362 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1363 (__mmask8)(U), (int)(C), (int)(R)))
1364
1365 #define _mm512_sqrt_round_ph(A, R) \
1366 ((__m512h)__builtin_ia32_sqrtph512((__v32hf)(__m512h)(A), (int)(R)))
1367
1368 #define _mm512_mask_sqrt_round_ph(W, U, A, R) \
1369 ((__m512h)__builtin_ia32_selectph_512( \
1370 (__mmask32)(U), (__v32hf)_mm512_sqrt_round_ph((A), (R)), \
1371 (__v32hf)(__m512h)(W)))
1372
1373 #define _mm512_maskz_sqrt_round_ph(U, A, R) \
1374 ((__m512h)__builtin_ia32_selectph_512( \
1375 (__mmask32)(U), (__v32hf)_mm512_sqrt_round_ph((A), (R)), \
1376 (__v32hf)_mm512_setzero_ph()))
1377
1378 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_sqrt_ph(__m512h __A) {
1379 return (__m512h)__builtin_ia32_sqrtph512((__v32hf)__A,
1380 _MM_FROUND_CUR_DIRECTION);
1381 }
1382
1383 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1384 _mm512_mask_sqrt_ph(__m512h __W, __mmask32 __U, __m512h __A) {
1385 return (__m512h)__builtin_ia32_selectph_512(
1386 (__mmask32)(__U),
1387 (__v32hf)__builtin_ia32_sqrtph512((__A), (_MM_FROUND_CUR_DIRECTION)),
1388 (__v32hf)(__m512h)(__W));
1389 }
1390
1391 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1392 _mm512_maskz_sqrt_ph(__mmask32 __U, __m512h __A) {
1393 return (__m512h)__builtin_ia32_selectph_512(
1394 (__mmask32)(__U),
1395 (__v32hf)__builtin_ia32_sqrtph512((__A), (_MM_FROUND_CUR_DIRECTION)),
1396 (__v32hf)_mm512_setzero_ph());
1397 }
1398
1399 #define _mm_sqrt_round_sh(A, B, R) \
1400 ((__m128h)__builtin_ia32_sqrtsh_round_mask( \
1401 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1402 (__mmask8)-1, (int)(R)))
1403
1404 #define _mm_mask_sqrt_round_sh(W, U, A, B, R) \
1405 ((__m128h)__builtin_ia32_sqrtsh_round_mask( \
1406 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W), \
1407 (__mmask8)(U), (int)(R)))
1408
1409 #define _mm_maskz_sqrt_round_sh(U, A, B, R) \
1410 ((__m128h)__builtin_ia32_sqrtsh_round_mask( \
1411 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), \
1412 (__mmask8)(U), (int)(R)))
1413
1414 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_sqrt_sh(__m128h __A,
1415 __m128h __B) {
1416 return (__m128h)__builtin_ia32_sqrtsh_round_mask(
1417 (__v8hf)(__m128h)(__A), (__v8hf)(__m128h)(__B), (__v8hf)_mm_setzero_ph(),
1418 (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
1419 }
1420
1421 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_sqrt_sh(__m128h __W,
1422 __mmask32 __U,
1423 __m128h __A,
1424 __m128h __B) {
1425 return (__m128h)__builtin_ia32_sqrtsh_round_mask(
1426 (__v8hf)(__m128h)(__A), (__v8hf)(__m128h)(__B), (__v8hf)(__m128h)(__W),
1427 (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
1428 }
1429
1430 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_sqrt_sh(__mmask32 __U,
1431 __m128h __A,
1432 __m128h __B) {
1433 return (__m128h)__builtin_ia32_sqrtsh_round_mask(
1434 (__v8hf)(__m128h)(__A), (__v8hf)(__m128h)(__B), (__v8hf)_mm_setzero_ph(),
1435 (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
1436 }
1437
1438 #define _mm512_mask_fpclass_ph_mask(U, A, imm) \
1439 ((__mmask32)__builtin_ia32_fpclassph512_mask((__v32hf)(__m512h)(A), \
1440 (int)(imm), (__mmask32)(U)))
1441
1442 #define _mm512_fpclass_ph_mask(A, imm) \
1443 ((__mmask32)__builtin_ia32_fpclassph512_mask((__v32hf)(__m512h)(A), \
1444 (int)(imm), (__mmask32)-1))
1445
1446 #define _mm_fpclass_sh_mask(A, imm) \
1447 ((__mmask8)__builtin_ia32_fpclasssh_mask((__v8hf)(__m128h)(A), (int)(imm), \
1448 (__mmask8)-1))
1449
1450 #define _mm_mask_fpclass_sh_mask(U, A, imm) \
1451 ((__mmask8)__builtin_ia32_fpclasssh_mask((__v8hf)(__m128h)(A), (int)(imm), \
1452 (__mmask8)(U)))
1453
1454 #define _mm512_cvt_roundpd_ph(A, R) \
1455 ((__m128h)__builtin_ia32_vcvtpd2ph512_mask( \
1456 (__v8df)(A), (__v8hf)_mm_undefined_ph(), (__mmask8)(-1), (int)(R)))
1457
1458 #define _mm512_mask_cvt_roundpd_ph(W, U, A, R) \
1459 ((__m128h)__builtin_ia32_vcvtpd2ph512_mask((__v8df)(A), (__v8hf)(W), \
1460 (__mmask8)(U), (int)(R)))
1461
1462 #define _mm512_maskz_cvt_roundpd_ph(U, A, R) \
1463 ((__m128h)__builtin_ia32_vcvtpd2ph512_mask( \
1464 (__v8df)(A), (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
1465
1466 static __inline__ __m128h __DEFAULT_FN_ATTRS512 _mm512_cvtpd_ph(__m512d __A) {
1467 return (__m128h)__builtin_ia32_vcvtpd2ph512_mask(
1468 (__v8df)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
1469 _MM_FROUND_CUR_DIRECTION);
1470 }
1471
1472 static __inline__ __m128h __DEFAULT_FN_ATTRS512
1473 _mm512_mask_cvtpd_ph(__m128h __W, __mmask8 __U, __m512d __A) {
1474 return (__m128h)__builtin_ia32_vcvtpd2ph512_mask(
1475 (__v8df)__A, (__v8hf)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
1476 }
1477
1478 static __inline__ __m128h __DEFAULT_FN_ATTRS512
1479 _mm512_maskz_cvtpd_ph(__mmask8 __U, __m512d __A) {
1480 return (__m128h)__builtin_ia32_vcvtpd2ph512_mask(
1481 (__v8df)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
1482 _MM_FROUND_CUR_DIRECTION);
1483 }
1484
1485 #define _mm512_cvt_roundph_pd(A, R) \
1486 ((__m512d)__builtin_ia32_vcvtph2pd512_mask( \
1487 (__v8hf)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), (int)(R)))
1488
1489 #define _mm512_mask_cvt_roundph_pd(W, U, A, R) \
1490 ((__m512d)__builtin_ia32_vcvtph2pd512_mask((__v8hf)(A), (__v8df)(W), \
1491 (__mmask8)(U), (int)(R)))
1492
1493 #define _mm512_maskz_cvt_roundph_pd(U, A, R) \
1494 ((__m512d)__builtin_ia32_vcvtph2pd512_mask( \
1495 (__v8hf)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), (int)(R)))
1496
1497 static __inline__ __m512d __DEFAULT_FN_ATTRS512 _mm512_cvtph_pd(__m128h __A) {
1498 return (__m512d)__builtin_ia32_vcvtph2pd512_mask(
1499 (__v8hf)__A, (__v8df)_mm512_setzero_pd(), (__mmask8)-1,
1500 _MM_FROUND_CUR_DIRECTION);
1501 }
1502
1503 static __inline__ __m512d __DEFAULT_FN_ATTRS512
1504 _mm512_mask_cvtph_pd(__m512d __W, __mmask8 __U, __m128h __A) {
1505 return (__m512d)__builtin_ia32_vcvtph2pd512_mask(
1506 (__v8hf)__A, (__v8df)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
1507 }
1508
1509 static __inline__ __m512d __DEFAULT_FN_ATTRS512
1510 _mm512_maskz_cvtph_pd(__mmask8 __U, __m128h __A) {
1511 return (__m512d)__builtin_ia32_vcvtph2pd512_mask(
1512 (__v8hf)__A, (__v8df)_mm512_setzero_pd(), (__mmask8)__U,
1513 _MM_FROUND_CUR_DIRECTION);
1514 }
1515
1516 #define _mm_cvt_roundsh_ss(A, B, R) \
1517 ((__m128)__builtin_ia32_vcvtsh2ss_round_mask((__v4sf)(A), (__v8hf)(B), \
1518 (__v4sf)_mm_undefined_ps(), \
1519 (__mmask8)(-1), (int)(R)))
1520
1521 #define _mm_mask_cvt_roundsh_ss(W, U, A, B, R) \
1522 ((__m128)__builtin_ia32_vcvtsh2ss_round_mask( \
1523 (__v4sf)(A), (__v8hf)(B), (__v4sf)(W), (__mmask8)(U), (int)(R)))
1524
1525 #define _mm_maskz_cvt_roundsh_ss(U, A, B, R) \
1526 ((__m128)__builtin_ia32_vcvtsh2ss_round_mask((__v4sf)(A), (__v8hf)(B), \
1527 (__v4sf)_mm_setzero_ps(), \
1528 (__mmask8)(U), (int)(R)))
1529
1530 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_cvtsh_ss(__m128 __A,
1531 __m128h __B) {
1532 return (__m128)__builtin_ia32_vcvtsh2ss_round_mask(
1533 (__v4sf)__A, (__v8hf)__B, (__v4sf)_mm_undefined_ps(), (__mmask8)-1,
1534 _MM_FROUND_CUR_DIRECTION);
1535 }
1536
1537 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_mask_cvtsh_ss(__m128 __W,
1538 __mmask8 __U,
1539 __m128 __A,
1540 __m128h __B) {
1541 return (__m128)__builtin_ia32_vcvtsh2ss_round_mask((__v4sf)__A, (__v8hf)__B,
1542 (__v4sf)__W, (__mmask8)__U,
1543 _MM_FROUND_CUR_DIRECTION);
1544 }
1545
1546 static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_maskz_cvtsh_ss(__mmask8 __U,
1547 __m128 __A,
1548 __m128h __B) {
1549 return (__m128)__builtin_ia32_vcvtsh2ss_round_mask(
1550 (__v4sf)__A, (__v8hf)__B, (__v4sf)_mm_setzero_ps(), (__mmask8)__U,
1551 _MM_FROUND_CUR_DIRECTION);
1552 }
1553
1554 #define _mm_cvt_roundss_sh(A, B, R) \
1555 ((__m128h)__builtin_ia32_vcvtss2sh_round_mask((__v8hf)(A), (__v4sf)(B), \
1556 (__v8hf)_mm_undefined_ph(), \
1557 (__mmask8)(-1), (int)(R)))
1558
1559 #define _mm_mask_cvt_roundss_sh(W, U, A, B, R) \
1560 ((__m128h)__builtin_ia32_vcvtss2sh_round_mask( \
1561 (__v8hf)(A), (__v4sf)(B), (__v8hf)(W), (__mmask8)(U), (int)(R)))
1562
1563 #define _mm_maskz_cvt_roundss_sh(U, A, B, R) \
1564 ((__m128h)__builtin_ia32_vcvtss2sh_round_mask((__v8hf)(A), (__v4sf)(B), \
1565 (__v8hf)_mm_setzero_ph(), \
1566 (__mmask8)(U), (int)(R)))
1567
1568 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtss_sh(__m128h __A,
1569 __m128 __B) {
1570 return (__m128h)__builtin_ia32_vcvtss2sh_round_mask(
1571 (__v8hf)__A, (__v4sf)__B, (__v8hf)_mm_undefined_ph(), (__mmask8)-1,
1572 _MM_FROUND_CUR_DIRECTION);
1573 }
1574
1575 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_cvtss_sh(__m128h __W,
1576 __mmask8 __U,
1577 __m128h __A,
1578 __m128 __B) {
1579 return (__m128h)__builtin_ia32_vcvtss2sh_round_mask(
1580 (__v8hf)__A, (__v4sf)__B, (__v8hf)__W, (__mmask8)__U,
1581 _MM_FROUND_CUR_DIRECTION);
1582 }
1583
1584 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_cvtss_sh(__mmask8 __U,
1585 __m128h __A,
1586 __m128 __B) {
1587 return (__m128h)__builtin_ia32_vcvtss2sh_round_mask(
1588 (__v8hf)__A, (__v4sf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
1589 _MM_FROUND_CUR_DIRECTION);
1590 }
1591
1592 #define _mm_cvt_roundsd_sh(A, B, R) \
1593 ((__m128h)__builtin_ia32_vcvtsd2sh_round_mask((__v8hf)(A), (__v2df)(B), \
1594 (__v8hf)_mm_undefined_ph(), \
1595 (__mmask8)(-1), (int)(R)))
1596
1597 #define _mm_mask_cvt_roundsd_sh(W, U, A, B, R) \
1598 ((__m128h)__builtin_ia32_vcvtsd2sh_round_mask( \
1599 (__v8hf)(A), (__v2df)(B), (__v8hf)(W), (__mmask8)(U), (int)(R)))
1600
1601 #define _mm_maskz_cvt_roundsd_sh(U, A, B, R) \
1602 ((__m128h)__builtin_ia32_vcvtsd2sh_round_mask((__v8hf)(A), (__v2df)(B), \
1603 (__v8hf)_mm_setzero_ph(), \
1604 (__mmask8)(U), (int)(R)))
1605
1606 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtsd_sh(__m128h __A,
1607 __m128d __B) {
1608 return (__m128h)__builtin_ia32_vcvtsd2sh_round_mask(
1609 (__v8hf)__A, (__v2df)__B, (__v8hf)_mm_undefined_ph(), (__mmask8)-1,
1610 _MM_FROUND_CUR_DIRECTION);
1611 }
1612
1613 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_cvtsd_sh(__m128h __W,
1614 __mmask8 __U,
1615 __m128h __A,
1616 __m128d __B) {
1617 return (__m128h)__builtin_ia32_vcvtsd2sh_round_mask(
1618 (__v8hf)__A, (__v2df)__B, (__v8hf)__W, (__mmask8)__U,
1619 _MM_FROUND_CUR_DIRECTION);
1620 }
1621
1622 static __inline__ __m128h __DEFAULT_FN_ATTRS128
1623 _mm_maskz_cvtsd_sh(__mmask8 __U, __m128h __A, __m128d __B) {
1624 return (__m128h)__builtin_ia32_vcvtsd2sh_round_mask(
1625 (__v8hf)__A, (__v2df)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
1626 _MM_FROUND_CUR_DIRECTION);
1627 }
1628
1629 #define _mm_cvt_roundsh_sd(A, B, R) \
1630 ((__m128d)__builtin_ia32_vcvtsh2sd_round_mask((__v2df)(A), (__v8hf)(B), \
1631 (__v2df)_mm_undefined_pd(), \
1632 (__mmask8)(-1), (int)(R)))
1633
1634 #define _mm_mask_cvt_roundsh_sd(W, U, A, B, R) \
1635 ((__m128d)__builtin_ia32_vcvtsh2sd_round_mask( \
1636 (__v2df)(A), (__v8hf)(B), (__v2df)(W), (__mmask8)(U), (int)(R)))
1637
1638 #define _mm_maskz_cvt_roundsh_sd(U, A, B, R) \
1639 ((__m128d)__builtin_ia32_vcvtsh2sd_round_mask((__v2df)(A), (__v8hf)(B), \
1640 (__v2df)_mm_setzero_pd(), \
1641 (__mmask8)(U), (int)(R)))
1642
1643 static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_cvtsh_sd(__m128d __A,
1644 __m128h __B) {
1645 return (__m128d)__builtin_ia32_vcvtsh2sd_round_mask(
1646 (__v2df)__A, (__v8hf)__B, (__v2df)_mm_undefined_pd(), (__mmask8)-1,
1647 _MM_FROUND_CUR_DIRECTION);
1648 }
1649
1650 static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_mask_cvtsh_sd(__m128d __W,
1651 __mmask8 __U,
1652 __m128d __A,
1653 __m128h __B) {
1654 return (__m128d)__builtin_ia32_vcvtsh2sd_round_mask(
1655 (__v2df)__A, (__v8hf)__B, (__v2df)__W, (__mmask8)__U,
1656 _MM_FROUND_CUR_DIRECTION);
1657 }
1658
1659 static __inline__ __m128d __DEFAULT_FN_ATTRS128
1660 _mm_maskz_cvtsh_sd(__mmask8 __U, __m128d __A, __m128h __B) {
1661 return (__m128d)__builtin_ia32_vcvtsh2sd_round_mask(
1662 (__v2df)__A, (__v8hf)__B, (__v2df)_mm_setzero_pd(), (__mmask8)__U,
1663 _MM_FROUND_CUR_DIRECTION);
1664 }
1665
1666 #define _mm512_cvt_roundph_epi16(A, R) \
1667 ((__m512i)__builtin_ia32_vcvtph2w512_mask((__v32hf)(A), \
1668 (__v32hi)_mm512_undefined_epi32(), \
1669 (__mmask32)(-1), (int)(R)))
1670
1671 #define _mm512_mask_cvt_roundph_epi16(W, U, A, R) \
1672 ((__m512i)__builtin_ia32_vcvtph2w512_mask((__v32hf)(A), (__v32hi)(W), \
1673 (__mmask32)(U), (int)(R)))
1674
1675 #define _mm512_maskz_cvt_roundph_epi16(U, A, R) \
1676 ((__m512i)__builtin_ia32_vcvtph2w512_mask((__v32hf)(A), \
1677 (__v32hi)_mm512_setzero_epi32(), \
1678 (__mmask32)(U), (int)(R)))
1679
1680 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1681 _mm512_cvtph_epi16(__m512h __A) {
1682 return (__m512i)__builtin_ia32_vcvtph2w512_mask(
1683 (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)-1,
1684 _MM_FROUND_CUR_DIRECTION);
1685 }
1686
1687 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1688 _mm512_mask_cvtph_epi16(__m512i __W, __mmask32 __U, __m512h __A) {
1689 return (__m512i)__builtin_ia32_vcvtph2w512_mask(
1690 (__v32hf)__A, (__v32hi)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
1691 }
1692
1693 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1694 _mm512_maskz_cvtph_epi16(__mmask32 __U, __m512h __A) {
1695 return (__m512i)__builtin_ia32_vcvtph2w512_mask(
1696 (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)__U,
1697 _MM_FROUND_CUR_DIRECTION);
1698 }
1699
1700 #define _mm512_cvtt_roundph_epi16(A, R) \
1701 ((__m512i)__builtin_ia32_vcvttph2w512_mask( \
1702 (__v32hf)(A), (__v32hi)_mm512_undefined_epi32(), (__mmask32)(-1), \
1703 (int)(R)))
1704
1705 #define _mm512_mask_cvtt_roundph_epi16(W, U, A, R) \
1706 ((__m512i)__builtin_ia32_vcvttph2w512_mask((__v32hf)(A), (__v32hi)(W), \
1707 (__mmask32)(U), (int)(R)))
1708
1709 #define _mm512_maskz_cvtt_roundph_epi16(U, A, R) \
1710 ((__m512i)__builtin_ia32_vcvttph2w512_mask((__v32hf)(A), \
1711 (__v32hi)_mm512_setzero_epi32(), \
1712 (__mmask32)(U), (int)(R)))
1713
1714 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1715 _mm512_cvttph_epi16(__m512h __A) {
1716 return (__m512i)__builtin_ia32_vcvttph2w512_mask(
1717 (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)-1,
1718 _MM_FROUND_CUR_DIRECTION);
1719 }
1720
1721 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1722 _mm512_mask_cvttph_epi16(__m512i __W, __mmask32 __U, __m512h __A) {
1723 return (__m512i)__builtin_ia32_vcvttph2w512_mask(
1724 (__v32hf)__A, (__v32hi)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
1725 }
1726
1727 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1728 _mm512_maskz_cvttph_epi16(__mmask32 __U, __m512h __A) {
1729 return (__m512i)__builtin_ia32_vcvttph2w512_mask(
1730 (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)__U,
1731 _MM_FROUND_CUR_DIRECTION);
1732 }
1733
1734 #define _mm512_cvt_roundepi16_ph(A, R) \
1735 ((__m512h)__builtin_ia32_vcvtw2ph512_mask((__v32hi)(A), \
1736 (__v32hf)_mm512_undefined_ph(), \
1737 (__mmask32)(-1), (int)(R)))
1738
1739 #define _mm512_mask_cvt_roundepi16_ph(W, U, A, R) \
1740 ((__m512h)__builtin_ia32_vcvtw2ph512_mask((__v32hi)(A), (__v32hf)(W), \
1741 (__mmask32)(U), (int)(R)))
1742
1743 #define _mm512_maskz_cvt_roundepi16_ph(U, A, R) \
1744 ((__m512h)__builtin_ia32_vcvtw2ph512_mask( \
1745 (__v32hi)(A), (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
1746
1747 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1748 _mm512_cvtepi16_ph(__m512i __A) {
1749 return (__m512h)__builtin_ia32_vcvtw2ph512_mask(
1750 (__v32hi)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)-1,
1751 _MM_FROUND_CUR_DIRECTION);
1752 }
1753
1754 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1755 _mm512_mask_cvtepi16_ph(__m512h __W, __mmask32 __U, __m512i __A) {
1756 return (__m512h)__builtin_ia32_vcvtw2ph512_mask(
1757 (__v32hi)__A, (__v32hf)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
1758 }
1759
1760 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1761 _mm512_maskz_cvtepi16_ph(__mmask32 __U, __m512i __A) {
1762 return (__m512h)__builtin_ia32_vcvtw2ph512_mask(
1763 (__v32hi)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
1764 _MM_FROUND_CUR_DIRECTION);
1765 }
1766
1767 #define _mm512_cvt_roundph_epu16(A, R) \
1768 ((__m512i)__builtin_ia32_vcvtph2uw512_mask( \
1769 (__v32hf)(A), (__v32hu)_mm512_undefined_epi32(), (__mmask32)(-1), \
1770 (int)(R)))
1771
1772 #define _mm512_mask_cvt_roundph_epu16(W, U, A, R) \
1773 ((__m512i)__builtin_ia32_vcvtph2uw512_mask((__v32hf)(A), (__v32hu)(W), \
1774 (__mmask32)(U), (int)(R)))
1775
1776 #define _mm512_maskz_cvt_roundph_epu16(U, A, R) \
1777 ((__m512i)__builtin_ia32_vcvtph2uw512_mask((__v32hf)(A), \
1778 (__v32hu)_mm512_setzero_epi32(), \
1779 (__mmask32)(U), (int)(R)))
1780
1781 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1782 _mm512_cvtph_epu16(__m512h __A) {
1783 return (__m512i)__builtin_ia32_vcvtph2uw512_mask(
1784 (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)-1,
1785 _MM_FROUND_CUR_DIRECTION);
1786 }
1787
1788 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1789 _mm512_mask_cvtph_epu16(__m512i __W, __mmask32 __U, __m512h __A) {
1790 return (__m512i)__builtin_ia32_vcvtph2uw512_mask(
1791 (__v32hf)__A, (__v32hu)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
1792 }
1793
1794 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1795 _mm512_maskz_cvtph_epu16(__mmask32 __U, __m512h __A) {
1796 return (__m512i)__builtin_ia32_vcvtph2uw512_mask(
1797 (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)__U,
1798 _MM_FROUND_CUR_DIRECTION);
1799 }
1800
1801 #define _mm512_cvtt_roundph_epu16(A, R) \
1802 ((__m512i)__builtin_ia32_vcvttph2uw512_mask( \
1803 (__v32hf)(A), (__v32hu)_mm512_undefined_epi32(), (__mmask32)(-1), \
1804 (int)(R)))
1805
1806 #define _mm512_mask_cvtt_roundph_epu16(W, U, A, R) \
1807 ((__m512i)__builtin_ia32_vcvttph2uw512_mask((__v32hf)(A), (__v32hu)(W), \
1808 (__mmask32)(U), (int)(R)))
1809
1810 #define _mm512_maskz_cvtt_roundph_epu16(U, A, R) \
1811 ((__m512i)__builtin_ia32_vcvttph2uw512_mask((__v32hf)(A), \
1812 (__v32hu)_mm512_setzero_epi32(), \
1813 (__mmask32)(U), (int)(R)))
1814
1815 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1816 _mm512_cvttph_epu16(__m512h __A) {
1817 return (__m512i)__builtin_ia32_vcvttph2uw512_mask(
1818 (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)-1,
1819 _MM_FROUND_CUR_DIRECTION);
1820 }
1821
1822 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1823 _mm512_mask_cvttph_epu16(__m512i __W, __mmask32 __U, __m512h __A) {
1824 return (__m512i)__builtin_ia32_vcvttph2uw512_mask(
1825 (__v32hf)__A, (__v32hu)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
1826 }
1827
1828 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1829 _mm512_maskz_cvttph_epu16(__mmask32 __U, __m512h __A) {
1830 return (__m512i)__builtin_ia32_vcvttph2uw512_mask(
1831 (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)__U,
1832 _MM_FROUND_CUR_DIRECTION);
1833 }
1834
1835 #define _mm512_cvt_roundepu16_ph(A, R) \
1836 ((__m512h)__builtin_ia32_vcvtuw2ph512_mask((__v32hu)(A), \
1837 (__v32hf)_mm512_undefined_ph(), \
1838 (__mmask32)(-1), (int)(R)))
1839
1840 #define _mm512_mask_cvt_roundepu16_ph(W, U, A, R) \
1841 ((__m512h)__builtin_ia32_vcvtuw2ph512_mask((__v32hu)(A), (__v32hf)(W), \
1842 (__mmask32)(U), (int)(R)))
1843
1844 #define _mm512_maskz_cvt_roundepu16_ph(U, A, R) \
1845 ((__m512h)__builtin_ia32_vcvtuw2ph512_mask( \
1846 (__v32hu)(A), (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
1847
1848 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1849 _mm512_cvtepu16_ph(__m512i __A) {
1850 return (__m512h)__builtin_ia32_vcvtuw2ph512_mask(
1851 (__v32hu)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)-1,
1852 _MM_FROUND_CUR_DIRECTION);
1853 }
1854
1855 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1856 _mm512_mask_cvtepu16_ph(__m512h __W, __mmask32 __U, __m512i __A) {
1857 return (__m512h)__builtin_ia32_vcvtuw2ph512_mask(
1858 (__v32hu)__A, (__v32hf)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
1859 }
1860
1861 static __inline__ __m512h __DEFAULT_FN_ATTRS512
1862 _mm512_maskz_cvtepu16_ph(__mmask32 __U, __m512i __A) {
1863 return (__m512h)__builtin_ia32_vcvtuw2ph512_mask(
1864 (__v32hu)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
1865 _MM_FROUND_CUR_DIRECTION);
1866 }
1867
1868 #define _mm512_cvt_roundph_epi32(A, R) \
1869 ((__m512i)__builtin_ia32_vcvtph2dq512_mask( \
1870 (__v16hf)(A), (__v16si)_mm512_undefined_epi32(), (__mmask16)(-1), \
1871 (int)(R)))
1872
1873 #define _mm512_mask_cvt_roundph_epi32(W, U, A, R) \
1874 ((__m512i)__builtin_ia32_vcvtph2dq512_mask((__v16hf)(A), (__v16si)(W), \
1875 (__mmask16)(U), (int)(R)))
1876
1877 #define _mm512_maskz_cvt_roundph_epi32(U, A, R) \
1878 ((__m512i)__builtin_ia32_vcvtph2dq512_mask((__v16hf)(A), \
1879 (__v16si)_mm512_setzero_epi32(), \
1880 (__mmask16)(U), (int)(R)))
1881
1882 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1883 _mm512_cvtph_epi32(__m256h __A) {
1884 return (__m512i)__builtin_ia32_vcvtph2dq512_mask(
1885 (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)-1,
1886 _MM_FROUND_CUR_DIRECTION);
1887 }
1888
1889 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1890 _mm512_mask_cvtph_epi32(__m512i __W, __mmask16 __U, __m256h __A) {
1891 return (__m512i)__builtin_ia32_vcvtph2dq512_mask(
1892 (__v16hf)__A, (__v16si)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
1893 }
1894
1895 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1896 _mm512_maskz_cvtph_epi32(__mmask16 __U, __m256h __A) {
1897 return (__m512i)__builtin_ia32_vcvtph2dq512_mask(
1898 (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)__U,
1899 _MM_FROUND_CUR_DIRECTION);
1900 }
1901
1902 #define _mm512_cvt_roundph_epu32(A, R) \
1903 ((__m512i)__builtin_ia32_vcvtph2udq512_mask( \
1904 (__v16hf)(A), (__v16su)_mm512_undefined_epi32(), (__mmask16)(-1), \
1905 (int)(R)))
1906
1907 #define _mm512_mask_cvt_roundph_epu32(W, U, A, R) \
1908 ((__m512i)__builtin_ia32_vcvtph2udq512_mask((__v16hf)(A), (__v16su)(W), \
1909 (__mmask16)(U), (int)(R)))
1910
1911 #define _mm512_maskz_cvt_roundph_epu32(U, A, R) \
1912 ((__m512i)__builtin_ia32_vcvtph2udq512_mask((__v16hf)(A), \
1913 (__v16su)_mm512_setzero_epi32(), \
1914 (__mmask16)(U), (int)(R)))
1915
1916 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1917 _mm512_cvtph_epu32(__m256h __A) {
1918 return (__m512i)__builtin_ia32_vcvtph2udq512_mask(
1919 (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)-1,
1920 _MM_FROUND_CUR_DIRECTION);
1921 }
1922
1923 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1924 _mm512_mask_cvtph_epu32(__m512i __W, __mmask16 __U, __m256h __A) {
1925 return (__m512i)__builtin_ia32_vcvtph2udq512_mask(
1926 (__v16hf)__A, (__v16su)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
1927 }
1928
1929 static __inline__ __m512i __DEFAULT_FN_ATTRS512
1930 _mm512_maskz_cvtph_epu32(__mmask16 __U, __m256h __A) {
1931 return (__m512i)__builtin_ia32_vcvtph2udq512_mask(
1932 (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)__U,
1933 _MM_FROUND_CUR_DIRECTION);
1934 }
1935
1936 #define _mm512_cvt_roundepi32_ph(A, R) \
1937 ((__m256h)__builtin_ia32_vcvtdq2ph512_mask((__v16si)(A), \
1938 (__v16hf)_mm256_undefined_ph(), \
1939 (__mmask16)(-1), (int)(R)))
1940
1941 #define _mm512_mask_cvt_roundepi32_ph(W, U, A, R) \
1942 ((__m256h)__builtin_ia32_vcvtdq2ph512_mask((__v16si)(A), (__v16hf)(W), \
1943 (__mmask16)(U), (int)(R)))
1944
1945 #define _mm512_maskz_cvt_roundepi32_ph(U, A, R) \
1946 ((__m256h)__builtin_ia32_vcvtdq2ph512_mask( \
1947 (__v16si)(A), (__v16hf)_mm256_setzero_ph(), (__mmask16)(U), (int)(R)))
1948
1949 static __inline__ __m256h __DEFAULT_FN_ATTRS512
1950 _mm512_cvtepi32_ph(__m512i __A) {
1951 return (__m256h)__builtin_ia32_vcvtdq2ph512_mask(
1952 (__v16si)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1,
1953 _MM_FROUND_CUR_DIRECTION);
1954 }
1955
1956 static __inline__ __m256h __DEFAULT_FN_ATTRS512
1957 _mm512_mask_cvtepi32_ph(__m256h __W, __mmask16 __U, __m512i __A) {
1958 return (__m256h)__builtin_ia32_vcvtdq2ph512_mask(
1959 (__v16si)__A, (__v16hf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
1960 }
1961
1962 static __inline__ __m256h __DEFAULT_FN_ATTRS512
1963 _mm512_maskz_cvtepi32_ph(__mmask16 __U, __m512i __A) {
1964 return (__m256h)__builtin_ia32_vcvtdq2ph512_mask(
1965 (__v16si)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U,
1966 _MM_FROUND_CUR_DIRECTION);
1967 }
1968
1969 #define _mm512_cvt_roundepu32_ph(A, R) \
1970 ((__m256h)__builtin_ia32_vcvtudq2ph512_mask((__v16su)(A), \
1971 (__v16hf)_mm256_undefined_ph(), \
1972 (__mmask16)(-1), (int)(R)))
1973
1974 #define _mm512_mask_cvt_roundepu32_ph(W, U, A, R) \
1975 ((__m256h)__builtin_ia32_vcvtudq2ph512_mask((__v16su)(A), (__v16hf)(W), \
1976 (__mmask16)(U), (int)(R)))
1977
1978 #define _mm512_maskz_cvt_roundepu32_ph(U, A, R) \
1979 ((__m256h)__builtin_ia32_vcvtudq2ph512_mask( \
1980 (__v16su)(A), (__v16hf)_mm256_setzero_ph(), (__mmask16)(U), (int)(R)))
1981
1982 static __inline__ __m256h __DEFAULT_FN_ATTRS512
1983 _mm512_cvtepu32_ph(__m512i __A) {
1984 return (__m256h)__builtin_ia32_vcvtudq2ph512_mask(
1985 (__v16su)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1,
1986 _MM_FROUND_CUR_DIRECTION);
1987 }
1988
1989 static __inline__ __m256h __DEFAULT_FN_ATTRS512
1990 _mm512_mask_cvtepu32_ph(__m256h __W, __mmask16 __U, __m512i __A) {
1991 return (__m256h)__builtin_ia32_vcvtudq2ph512_mask(
1992 (__v16su)__A, (__v16hf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
1993 }
1994
1995 static __inline__ __m256h __DEFAULT_FN_ATTRS512
1996 _mm512_maskz_cvtepu32_ph(__mmask16 __U, __m512i __A) {
1997 return (__m256h)__builtin_ia32_vcvtudq2ph512_mask(
1998 (__v16su)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U,
1999 _MM_FROUND_CUR_DIRECTION);
2000 }
2001
2002 #define _mm512_cvtt_roundph_epi32(A, R) \
2003 ((__m512i)__builtin_ia32_vcvttph2dq512_mask( \
2004 (__v16hf)(A), (__v16si)_mm512_undefined_epi32(), (__mmask16)(-1), \
2005 (int)(R)))
2006
2007 #define _mm512_mask_cvtt_roundph_epi32(W, U, A, R) \
2008 ((__m512i)__builtin_ia32_vcvttph2dq512_mask((__v16hf)(A), (__v16si)(W), \
2009 (__mmask16)(U), (int)(R)))
2010
2011 #define _mm512_maskz_cvtt_roundph_epi32(U, A, R) \
2012 ((__m512i)__builtin_ia32_vcvttph2dq512_mask((__v16hf)(A), \
2013 (__v16si)_mm512_setzero_epi32(), \
2014 (__mmask16)(U), (int)(R)))
2015
2016 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2017 _mm512_cvttph_epi32(__m256h __A) {
2018 return (__m512i)__builtin_ia32_vcvttph2dq512_mask(
2019 (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)-1,
2020 _MM_FROUND_CUR_DIRECTION);
2021 }
2022
2023 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2024 _mm512_mask_cvttph_epi32(__m512i __W, __mmask16 __U, __m256h __A) {
2025 return (__m512i)__builtin_ia32_vcvttph2dq512_mask(
2026 (__v16hf)__A, (__v16si)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
2027 }
2028
2029 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2030 _mm512_maskz_cvttph_epi32(__mmask16 __U, __m256h __A) {
2031 return (__m512i)__builtin_ia32_vcvttph2dq512_mask(
2032 (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)__U,
2033 _MM_FROUND_CUR_DIRECTION);
2034 }
2035
2036 #define _mm512_cvtt_roundph_epu32(A, R) \
2037 ((__m512i)__builtin_ia32_vcvttph2udq512_mask( \
2038 (__v16hf)(A), (__v16su)_mm512_undefined_epi32(), (__mmask16)(-1), \
2039 (int)(R)))
2040
2041 #define _mm512_mask_cvtt_roundph_epu32(W, U, A, R) \
2042 ((__m512i)__builtin_ia32_vcvttph2udq512_mask((__v16hf)(A), (__v16su)(W), \
2043 (__mmask16)(U), (int)(R)))
2044
2045 #define _mm512_maskz_cvtt_roundph_epu32(U, A, R) \
2046 ((__m512i)__builtin_ia32_vcvttph2udq512_mask( \
2047 (__v16hf)(A), (__v16su)_mm512_setzero_epi32(), (__mmask16)(U), \
2048 (int)(R)))
2049
2050 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2051 _mm512_cvttph_epu32(__m256h __A) {
2052 return (__m512i)__builtin_ia32_vcvttph2udq512_mask(
2053 (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)-1,
2054 _MM_FROUND_CUR_DIRECTION);
2055 }
2056
2057 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2058 _mm512_mask_cvttph_epu32(__m512i __W, __mmask16 __U, __m256h __A) {
2059 return (__m512i)__builtin_ia32_vcvttph2udq512_mask(
2060 (__v16hf)__A, (__v16su)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
2061 }
2062
2063 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2064 _mm512_maskz_cvttph_epu32(__mmask16 __U, __m256h __A) {
2065 return (__m512i)__builtin_ia32_vcvttph2udq512_mask(
2066 (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)__U,
2067 _MM_FROUND_CUR_DIRECTION);
2068 }
2069
2070 #define _mm512_cvt_roundepi64_ph(A, R) \
2071 ((__m128h)__builtin_ia32_vcvtqq2ph512_mask( \
2072 (__v8di)(A), (__v8hf)_mm_undefined_ph(), (__mmask8)(-1), (int)(R)))
2073
2074 #define _mm512_mask_cvt_roundepi64_ph(W, U, A, R) \
2075 ((__m128h)__builtin_ia32_vcvtqq2ph512_mask((__v8di)(A), (__v8hf)(W), \
2076 (__mmask8)(U), (int)(R)))
2077
2078 #define _mm512_maskz_cvt_roundepi64_ph(U, A, R) \
2079 ((__m128h)__builtin_ia32_vcvtqq2ph512_mask( \
2080 (__v8di)(A), (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
2081
2082 static __inline__ __m128h __DEFAULT_FN_ATTRS512
2083 _mm512_cvtepi64_ph(__m512i __A) {
2084 return (__m128h)__builtin_ia32_vcvtqq2ph512_mask(
2085 (__v8di)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
2086 _MM_FROUND_CUR_DIRECTION);
2087 }
2088
2089 static __inline__ __m128h __DEFAULT_FN_ATTRS512
2090 _mm512_mask_cvtepi64_ph(__m128h __W, __mmask8 __U, __m512i __A) {
2091 return (__m128h)__builtin_ia32_vcvtqq2ph512_mask(
2092 (__v8di)__A, (__v8hf)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2093 }
2094
2095 static __inline__ __m128h __DEFAULT_FN_ATTRS512
2096 _mm512_maskz_cvtepi64_ph(__mmask8 __U, __m512i __A) {
2097 return (__m128h)__builtin_ia32_vcvtqq2ph512_mask(
2098 (__v8di)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
2099 _MM_FROUND_CUR_DIRECTION);
2100 }
2101
2102 #define _mm512_cvt_roundph_epi64(A, R) \
2103 ((__m512i)__builtin_ia32_vcvtph2qq512_mask((__v8hf)(A), \
2104 (__v8di)_mm512_undefined_epi32(), \
2105 (__mmask8)(-1), (int)(R)))
2106
2107 #define _mm512_mask_cvt_roundph_epi64(W, U, A, R) \
2108 ((__m512i)__builtin_ia32_vcvtph2qq512_mask((__v8hf)(A), (__v8di)(W), \
2109 (__mmask8)(U), (int)(R)))
2110
2111 #define _mm512_maskz_cvt_roundph_epi64(U, A, R) \
2112 ((__m512i)__builtin_ia32_vcvtph2qq512_mask( \
2113 (__v8hf)(A), (__v8di)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
2114
2115 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2116 _mm512_cvtph_epi64(__m128h __A) {
2117 return (__m512i)__builtin_ia32_vcvtph2qq512_mask(
2118 (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)-1,
2119 _MM_FROUND_CUR_DIRECTION);
2120 }
2121
2122 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2123 _mm512_mask_cvtph_epi64(__m512i __W, __mmask8 __U, __m128h __A) {
2124 return (__m512i)__builtin_ia32_vcvtph2qq512_mask(
2125 (__v8hf)__A, (__v8di)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2126 }
2127
2128 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2129 _mm512_maskz_cvtph_epi64(__mmask8 __U, __m128h __A) {
2130 return (__m512i)__builtin_ia32_vcvtph2qq512_mask(
2131 (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)__U,
2132 _MM_FROUND_CUR_DIRECTION);
2133 }
2134
2135 #define _mm512_cvt_roundepu64_ph(A, R) \
2136 ((__m128h)__builtin_ia32_vcvtuqq2ph512_mask( \
2137 (__v8du)(A), (__v8hf)_mm_undefined_ph(), (__mmask8)(-1), (int)(R)))
2138
2139 #define _mm512_mask_cvt_roundepu64_ph(W, U, A, R) \
2140 ((__m128h)__builtin_ia32_vcvtuqq2ph512_mask((__v8du)(A), (__v8hf)(W), \
2141 (__mmask8)(U), (int)(R)))
2142
2143 #define _mm512_maskz_cvt_roundepu64_ph(U, A, R) \
2144 ((__m128h)__builtin_ia32_vcvtuqq2ph512_mask( \
2145 (__v8du)(A), (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
2146
2147 static __inline__ __m128h __DEFAULT_FN_ATTRS512
2148 _mm512_cvtepu64_ph(__m512i __A) {
2149 return (__m128h)__builtin_ia32_vcvtuqq2ph512_mask(
2150 (__v8du)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
2151 _MM_FROUND_CUR_DIRECTION);
2152 }
2153
2154 static __inline__ __m128h __DEFAULT_FN_ATTRS512
2155 _mm512_mask_cvtepu64_ph(__m128h __W, __mmask8 __U, __m512i __A) {
2156 return (__m128h)__builtin_ia32_vcvtuqq2ph512_mask(
2157 (__v8du)__A, (__v8hf)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2158 }
2159
2160 static __inline__ __m128h __DEFAULT_FN_ATTRS512
2161 _mm512_maskz_cvtepu64_ph(__mmask8 __U, __m512i __A) {
2162 return (__m128h)__builtin_ia32_vcvtuqq2ph512_mask(
2163 (__v8du)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
2164 _MM_FROUND_CUR_DIRECTION);
2165 }
2166
2167 #define _mm512_cvt_roundph_epu64(A, R) \
2168 ((__m512i)__builtin_ia32_vcvtph2uqq512_mask( \
2169 (__v8hf)(A), (__v8du)_mm512_undefined_epi32(), (__mmask8)(-1), \
2170 (int)(R)))
2171
2172 #define _mm512_mask_cvt_roundph_epu64(W, U, A, R) \
2173 ((__m512i)__builtin_ia32_vcvtph2uqq512_mask((__v8hf)(A), (__v8du)(W), \
2174 (__mmask8)(U), (int)(R)))
2175
2176 #define _mm512_maskz_cvt_roundph_epu64(U, A, R) \
2177 ((__m512i)__builtin_ia32_vcvtph2uqq512_mask( \
2178 (__v8hf)(A), (__v8du)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
2179
2180 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2181 _mm512_cvtph_epu64(__m128h __A) {
2182 return (__m512i)__builtin_ia32_vcvtph2uqq512_mask(
2183 (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)-1,
2184 _MM_FROUND_CUR_DIRECTION);
2185 }
2186
2187 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2188 _mm512_mask_cvtph_epu64(__m512i __W, __mmask8 __U, __m128h __A) {
2189 return (__m512i)__builtin_ia32_vcvtph2uqq512_mask(
2190 (__v8hf)__A, (__v8du)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2191 }
2192
2193 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2194 _mm512_maskz_cvtph_epu64(__mmask8 __U, __m128h __A) {
2195 return (__m512i)__builtin_ia32_vcvtph2uqq512_mask(
2196 (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)__U,
2197 _MM_FROUND_CUR_DIRECTION);
2198 }
2199
2200 #define _mm512_cvtt_roundph_epi64(A, R) \
2201 ((__m512i)__builtin_ia32_vcvttph2qq512_mask( \
2202 (__v8hf)(A), (__v8di)_mm512_undefined_epi32(), (__mmask8)(-1), \
2203 (int)(R)))
2204
2205 #define _mm512_mask_cvtt_roundph_epi64(W, U, A, R) \
2206 ((__m512i)__builtin_ia32_vcvttph2qq512_mask((__v8hf)(A), (__v8di)(W), \
2207 (__mmask8)(U), (int)(R)))
2208
2209 #define _mm512_maskz_cvtt_roundph_epi64(U, A, R) \
2210 ((__m512i)__builtin_ia32_vcvttph2qq512_mask( \
2211 (__v8hf)(A), (__v8di)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
2212
2213 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2214 _mm512_cvttph_epi64(__m128h __A) {
2215 return (__m512i)__builtin_ia32_vcvttph2qq512_mask(
2216 (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)-1,
2217 _MM_FROUND_CUR_DIRECTION);
2218 }
2219
2220 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2221 _mm512_mask_cvttph_epi64(__m512i __W, __mmask8 __U, __m128h __A) {
2222 return (__m512i)__builtin_ia32_vcvttph2qq512_mask(
2223 (__v8hf)__A, (__v8di)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2224 }
2225
2226 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2227 _mm512_maskz_cvttph_epi64(__mmask8 __U, __m128h __A) {
2228 return (__m512i)__builtin_ia32_vcvttph2qq512_mask(
2229 (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)__U,
2230 _MM_FROUND_CUR_DIRECTION);
2231 }
2232
2233 #define _mm512_cvtt_roundph_epu64(A, R) \
2234 ((__m512i)__builtin_ia32_vcvttph2uqq512_mask( \
2235 (__v8hf)(A), (__v8du)_mm512_undefined_epi32(), (__mmask8)(-1), \
2236 (int)(R)))
2237
2238 #define _mm512_mask_cvtt_roundph_epu64(W, U, A, R) \
2239 ((__m512i)__builtin_ia32_vcvttph2uqq512_mask((__v8hf)(A), (__v8du)(W), \
2240 (__mmask8)(U), (int)(R)))
2241
2242 #define _mm512_maskz_cvtt_roundph_epu64(U, A, R) \
2243 ((__m512i)__builtin_ia32_vcvttph2uqq512_mask( \
2244 (__v8hf)(A), (__v8du)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
2245
2246 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2247 _mm512_cvttph_epu64(__m128h __A) {
2248 return (__m512i)__builtin_ia32_vcvttph2uqq512_mask(
2249 (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)-1,
2250 _MM_FROUND_CUR_DIRECTION);
2251 }
2252
2253 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2254 _mm512_mask_cvttph_epu64(__m512i __W, __mmask8 __U, __m128h __A) {
2255 return (__m512i)__builtin_ia32_vcvttph2uqq512_mask(
2256 (__v8hf)__A, (__v8du)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2257 }
2258
2259 static __inline__ __m512i __DEFAULT_FN_ATTRS512
2260 _mm512_maskz_cvttph_epu64(__mmask8 __U, __m128h __A) {
2261 return (__m512i)__builtin_ia32_vcvttph2uqq512_mask(
2262 (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)__U,
2263 _MM_FROUND_CUR_DIRECTION);
2264 }
2265
2266 #define _mm_cvt_roundsh_i32(A, R) \
2267 ((int)__builtin_ia32_vcvtsh2si32((__v8hf)(A), (int)(R)))
2268
2269 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_cvtsh_i32(__m128h __A) {
2270 return (int)__builtin_ia32_vcvtsh2si32((__v8hf)__A, _MM_FROUND_CUR_DIRECTION);
2271 }
2272
2273 #define _mm_cvt_roundsh_u32(A, R) \
2274 ((unsigned int)__builtin_ia32_vcvtsh2usi32((__v8hf)(A), (int)(R)))
2275
2276 static __inline__ unsigned int __DEFAULT_FN_ATTRS128
2277 _mm_cvtsh_u32(__m128h __A) {
2278 return (unsigned int)__builtin_ia32_vcvtsh2usi32((__v8hf)__A,
2279 _MM_FROUND_CUR_DIRECTION);
2280 }
2281
2282 #ifdef __x86_64__
2283 #define _mm_cvt_roundsh_i64(A, R) \
2284 ((long long)__builtin_ia32_vcvtsh2si64((__v8hf)(A), (int)(R)))
2285
2286 static __inline__ long long __DEFAULT_FN_ATTRS128 _mm_cvtsh_i64(__m128h __A) {
2287 return (long long)__builtin_ia32_vcvtsh2si64((__v8hf)__A,
2288 _MM_FROUND_CUR_DIRECTION);
2289 }
2290
2291 #define _mm_cvt_roundsh_u64(A, R) \
2292 ((unsigned long long)__builtin_ia32_vcvtsh2usi64((__v8hf)(A), (int)(R)))
2293
2294 static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
2295 _mm_cvtsh_u64(__m128h __A) {
2296 return (unsigned long long)__builtin_ia32_vcvtsh2usi64(
2297 (__v8hf)__A, _MM_FROUND_CUR_DIRECTION);
2298 }
2299 #endif // __x86_64__
2300
2301 #define _mm_cvt_roundu32_sh(A, B, R) \
2302 ((__m128h)__builtin_ia32_vcvtusi2sh((__v8hf)(A), (unsigned int)(B), (int)(R)))
2303
2304 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2305 _mm_cvtu32_sh(__m128h __A, unsigned int __B) {
2306 __A[0] = __B;
2307 return __A;
2308 }
2309
2310 #ifdef __x86_64__
2311 #define _mm_cvt_roundu64_sh(A, B, R) \
2312 ((__m128h)__builtin_ia32_vcvtusi642sh((__v8hf)(A), (unsigned long long)(B), \
2313 (int)(R)))
2314
2315 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2316 _mm_cvtu64_sh(__m128h __A, unsigned long long __B) {
2317 __A[0] = __B;
2318 return __A;
2319 }
2320 #endif
2321
2322 #define _mm_cvt_roundi32_sh(A, B, R) \
2323 ((__m128h)__builtin_ia32_vcvtsi2sh((__v8hf)(A), (int)(B), (int)(R)))
2324
2325 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvti32_sh(__m128h __A,
2326 int __B) {
2327 __A[0] = __B;
2328 return __A;
2329 }
2330
2331 #ifdef __x86_64__
2332 #define _mm_cvt_roundi64_sh(A, B, R) \
2333 ((__m128h)__builtin_ia32_vcvtsi642sh((__v8hf)(A), (long long)(B), (int)(R)))
2334
2335 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvti64_sh(__m128h __A,
2336 long long __B) {
2337 __A[0] = __B;
2338 return __A;
2339 }
2340 #endif
2341
2342 #define _mm_cvtt_roundsh_i32(A, R) \
2343 ((int)__builtin_ia32_vcvttsh2si32((__v8hf)(A), (int)(R)))
2344
2345 static __inline__ int __DEFAULT_FN_ATTRS128 _mm_cvttsh_i32(__m128h __A) {
2346 return (int)__builtin_ia32_vcvttsh2si32((__v8hf)__A,
2347 _MM_FROUND_CUR_DIRECTION);
2348 }
2349
2350 #ifdef __x86_64__
2351 #define _mm_cvtt_roundsh_i64(A, R) \
2352 ((long long)__builtin_ia32_vcvttsh2si64((__v8hf)(A), (int)(R)))
2353
2354 static __inline__ long long __DEFAULT_FN_ATTRS128 _mm_cvttsh_i64(__m128h __A) {
2355 return (long long)__builtin_ia32_vcvttsh2si64((__v8hf)__A,
2356 _MM_FROUND_CUR_DIRECTION);
2357 }
2358 #endif
2359
2360 #define _mm_cvtt_roundsh_u32(A, R) \
2361 ((unsigned int)__builtin_ia32_vcvttsh2usi32((__v8hf)(A), (int)(R)))
2362
2363 static __inline__ unsigned int __DEFAULT_FN_ATTRS128
2364 _mm_cvttsh_u32(__m128h __A) {
2365 return (unsigned int)__builtin_ia32_vcvttsh2usi32((__v8hf)__A,
2366 _MM_FROUND_CUR_DIRECTION);
2367 }
2368
2369 #ifdef __x86_64__
2370 #define _mm_cvtt_roundsh_u64(A, R) \
2371 ((unsigned long long)__builtin_ia32_vcvttsh2usi64((__v8hf)(A), (int)(R)))
2372
2373 static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
2374 _mm_cvttsh_u64(__m128h __A) {
2375 return (unsigned long long)__builtin_ia32_vcvttsh2usi64(
2376 (__v8hf)__A, _MM_FROUND_CUR_DIRECTION);
2377 }
2378 #endif
2379
2380 #define _mm512_cvtx_roundph_ps(A, R) \
2381 ((__m512)__builtin_ia32_vcvtph2psx512_mask((__v16hf)(A), \
2382 (__v16sf)_mm512_undefined_ps(), \
2383 (__mmask16)(-1), (int)(R)))
2384
2385 #define _mm512_mask_cvtx_roundph_ps(W, U, A, R) \
2386 ((__m512)__builtin_ia32_vcvtph2psx512_mask((__v16hf)(A), (__v16sf)(W), \
2387 (__mmask16)(U), (int)(R)))
2388
2389 #define _mm512_maskz_cvtx_roundph_ps(U, A, R) \
2390 ((__m512)__builtin_ia32_vcvtph2psx512_mask( \
2391 (__v16hf)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), (int)(R)))
2392
2393 static __inline__ __m512 __DEFAULT_FN_ATTRS512 _mm512_cvtxph_ps(__m256h __A) {
2394 return (__m512)__builtin_ia32_vcvtph2psx512_mask(
2395 (__v16hf)__A, (__v16sf)_mm512_setzero_ps(), (__mmask16)-1,
2396 _MM_FROUND_CUR_DIRECTION);
2397 }
2398
2399 static __inline__ __m512 __DEFAULT_FN_ATTRS512
2400 _mm512_mask_cvtxph_ps(__m512 __W, __mmask16 __U, __m256h __A) {
2401 return (__m512)__builtin_ia32_vcvtph2psx512_mask(
2402 (__v16hf)__A, (__v16sf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
2403 }
2404
2405 static __inline__ __m512 __DEFAULT_FN_ATTRS512
2406 _mm512_maskz_cvtxph_ps(__mmask16 __U, __m256h __A) {
2407 return (__m512)__builtin_ia32_vcvtph2psx512_mask(
2408 (__v16hf)__A, (__v16sf)_mm512_setzero_ps(), (__mmask16)__U,
2409 _MM_FROUND_CUR_DIRECTION);
2410 }
2411
2412 #define _mm512_cvtx_roundps_ph(A, R) \
2413 ((__m256h)__builtin_ia32_vcvtps2phx512_mask((__v16sf)(A), \
2414 (__v16hf)_mm256_undefined_ph(), \
2415 (__mmask16)(-1), (int)(R)))
2416
2417 #define _mm512_mask_cvtx_roundps_ph(W, U, A, R) \
2418 ((__m256h)__builtin_ia32_vcvtps2phx512_mask((__v16sf)(A), (__v16hf)(W), \
2419 (__mmask16)(U), (int)(R)))
2420
2421 #define _mm512_maskz_cvtx_roundps_ph(U, A, R) \
2422 ((__m256h)__builtin_ia32_vcvtps2phx512_mask( \
2423 (__v16sf)(A), (__v16hf)_mm256_setzero_ph(), (__mmask16)(U), (int)(R)))
2424
2425 static __inline__ __m256h __DEFAULT_FN_ATTRS512 _mm512_cvtxps_ph(__m512 __A) {
2426 return (__m256h)__builtin_ia32_vcvtps2phx512_mask(
2427 (__v16sf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1,
2428 _MM_FROUND_CUR_DIRECTION);
2429 }
2430
2431 static __inline__ __m256h __DEFAULT_FN_ATTRS512
2432 _mm512_mask_cvtxps_ph(__m256h __W, __mmask16 __U, __m512 __A) {
2433 return (__m256h)__builtin_ia32_vcvtps2phx512_mask(
2434 (__v16sf)__A, (__v16hf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
2435 }
2436
2437 static __inline__ __m256h __DEFAULT_FN_ATTRS512
2438 _mm512_maskz_cvtxps_ph(__mmask16 __U, __m512 __A) {
2439 return (__m256h)__builtin_ia32_vcvtps2phx512_mask(
2440 (__v16sf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U,
2441 _MM_FROUND_CUR_DIRECTION);
2442 }
2443
2444 #define _mm512_fmadd_round_ph(A, B, C, R) \
2445 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2446 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2447 (__mmask32)-1, (int)(R)))
2448
2449 #define _mm512_mask_fmadd_round_ph(A, U, B, C, R) \
2450 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2451 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2452 (__mmask32)(U), (int)(R)))
2453
2454 #define _mm512_mask3_fmadd_round_ph(A, B, C, U, R) \
2455 ((__m512h)__builtin_ia32_vfmaddph512_mask3( \
2456 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2457 (__mmask32)(U), (int)(R)))
2458
2459 #define _mm512_maskz_fmadd_round_ph(U, A, B, C, R) \
2460 ((__m512h)__builtin_ia32_vfmaddph512_maskz( \
2461 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2462 (__mmask32)(U), (int)(R)))
2463
2464 #define _mm512_fmsub_round_ph(A, B, C, R) \
2465 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2466 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2467 (__mmask32)-1, (int)(R)))
2468
2469 #define _mm512_mask_fmsub_round_ph(A, U, B, C, R) \
2470 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2471 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2472 (__mmask32)(U), (int)(R)))
2473
2474 #define _mm512_maskz_fmsub_round_ph(U, A, B, C, R) \
2475 ((__m512h)__builtin_ia32_vfmaddph512_maskz( \
2476 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2477 (__mmask32)(U), (int)(R)))
2478
2479 #define _mm512_fnmadd_round_ph(A, B, C, R) \
2480 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2481 (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2482 (__mmask32)-1, (int)(R)))
2483
2484 #define _mm512_mask3_fnmadd_round_ph(A, B, C, U, R) \
2485 ((__m512h)__builtin_ia32_vfmaddph512_mask3( \
2486 -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2487 (__mmask32)(U), (int)(R)))
2488
2489 #define _mm512_maskz_fnmadd_round_ph(U, A, B, C, R) \
2490 ((__m512h)__builtin_ia32_vfmaddph512_maskz( \
2491 -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2492 (__mmask32)(U), (int)(R)))
2493
2494 #define _mm512_fnmsub_round_ph(A, B, C, R) \
2495 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2496 (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2497 (__mmask32)-1, (int)(R)))
2498
2499 #define _mm512_maskz_fnmsub_round_ph(U, A, B, C, R) \
2500 ((__m512h)__builtin_ia32_vfmaddph512_maskz( \
2501 -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2502 (__mmask32)(U), (int)(R)))
2503
2504 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmadd_ph(__m512h __A,
2505 __m512h __B,
2506 __m512h __C) {
2507 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
2508 (__v32hf)__C, (__mmask32)-1,
2509 _MM_FROUND_CUR_DIRECTION);
2510 }
2511
2512 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2513 _mm512_mask_fmadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
2514 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
2515 (__v32hf)__C, (__mmask32)__U,
2516 _MM_FROUND_CUR_DIRECTION);
2517 }
2518
2519 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2520 _mm512_mask3_fmadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
2521 return (__m512h)__builtin_ia32_vfmaddph512_mask3((__v32hf)__A, (__v32hf)__B,
2522 (__v32hf)__C, (__mmask32)__U,
2523 _MM_FROUND_CUR_DIRECTION);
2524 }
2525
2526 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2527 _mm512_maskz_fmadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
2528 return (__m512h)__builtin_ia32_vfmaddph512_maskz((__v32hf)__A, (__v32hf)__B,
2529 (__v32hf)__C, (__mmask32)__U,
2530 _MM_FROUND_CUR_DIRECTION);
2531 }
2532
2533 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmsub_ph(__m512h __A,
2534 __m512h __B,
2535 __m512h __C) {
2536 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
2537 -(__v32hf)__C, (__mmask32)-1,
2538 _MM_FROUND_CUR_DIRECTION);
2539 }
2540
2541 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2542 _mm512_mask_fmsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
2543 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
2544 -(__v32hf)__C, (__mmask32)__U,
2545 _MM_FROUND_CUR_DIRECTION);
2546 }
2547
2548 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2549 _mm512_maskz_fmsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
2550 return (__m512h)__builtin_ia32_vfmaddph512_maskz(
2551 (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
2552 _MM_FROUND_CUR_DIRECTION);
2553 }
2554
2555 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fnmadd_ph(__m512h __A,
2556 __m512h __B,
2557 __m512h __C) {
2558 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
2559 (__v32hf)__C, (__mmask32)-1,
2560 _MM_FROUND_CUR_DIRECTION);
2561 }
2562
2563 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2564 _mm512_mask3_fnmadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
2565 return (__m512h)__builtin_ia32_vfmaddph512_mask3(-(__v32hf)__A, (__v32hf)__B,
2566 (__v32hf)__C, (__mmask32)__U,
2567 _MM_FROUND_CUR_DIRECTION);
2568 }
2569
2570 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2571 _mm512_maskz_fnmadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
2572 return (__m512h)__builtin_ia32_vfmaddph512_maskz(-(__v32hf)__A, (__v32hf)__B,
2573 (__v32hf)__C, (__mmask32)__U,
2574 _MM_FROUND_CUR_DIRECTION);
2575 }
2576
2577 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fnmsub_ph(__m512h __A,
2578 __m512h __B,
2579 __m512h __C) {
2580 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
2581 -(__v32hf)__C, (__mmask32)-1,
2582 _MM_FROUND_CUR_DIRECTION);
2583 }
2584
2585 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2586 _mm512_maskz_fnmsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
2587 return (__m512h)__builtin_ia32_vfmaddph512_maskz(
2588 -(__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
2589 _MM_FROUND_CUR_DIRECTION);
2590 }
2591
2592 #define _mm512_fmaddsub_round_ph(A, B, C, R) \
2593 ((__m512h)__builtin_ia32_vfmaddsubph512_mask( \
2594 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2595 (__mmask32)-1, (int)(R)))
2596
2597 #define _mm512_mask_fmaddsub_round_ph(A, U, B, C, R) \
2598 ((__m512h)__builtin_ia32_vfmaddsubph512_mask( \
2599 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2600 (__mmask32)(U), (int)(R)))
2601
2602 #define _mm512_mask3_fmaddsub_round_ph(A, B, C, U, R) \
2603 ((__m512h)__builtin_ia32_vfmaddsubph512_mask3( \
2604 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2605 (__mmask32)(U), (int)(R)))
2606
2607 #define _mm512_maskz_fmaddsub_round_ph(U, A, B, C, R) \
2608 ((__m512h)__builtin_ia32_vfmaddsubph512_maskz( \
2609 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2610 (__mmask32)(U), (int)(R)))
2611
2612 #define _mm512_fmsubadd_round_ph(A, B, C, R) \
2613 ((__m512h)__builtin_ia32_vfmaddsubph512_mask( \
2614 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2615 (__mmask32)-1, (int)(R)))
2616
2617 #define _mm512_mask_fmsubadd_round_ph(A, U, B, C, R) \
2618 ((__m512h)__builtin_ia32_vfmaddsubph512_mask( \
2619 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2620 (__mmask32)(U), (int)(R)))
2621
2622 #define _mm512_maskz_fmsubadd_round_ph(U, A, B, C, R) \
2623 ((__m512h)__builtin_ia32_vfmaddsubph512_maskz( \
2624 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2625 (__mmask32)(U), (int)(R)))
2626
2627 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2628 _mm512_fmaddsub_ph(__m512h __A, __m512h __B, __m512h __C) {
2629 return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
2630 (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)-1,
2631 _MM_FROUND_CUR_DIRECTION);
2632 }
2633
2634 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2635 _mm512_mask_fmaddsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
2636 return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
2637 (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
2638 _MM_FROUND_CUR_DIRECTION);
2639 }
2640
2641 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2642 _mm512_mask3_fmaddsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
2643 return (__m512h)__builtin_ia32_vfmaddsubph512_mask3(
2644 (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
2645 _MM_FROUND_CUR_DIRECTION);
2646 }
2647
2648 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2649 _mm512_maskz_fmaddsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
2650 return (__m512h)__builtin_ia32_vfmaddsubph512_maskz(
2651 (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
2652 _MM_FROUND_CUR_DIRECTION);
2653 }
2654
2655 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2656 _mm512_fmsubadd_ph(__m512h __A, __m512h __B, __m512h __C) {
2657 return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
2658 (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)-1,
2659 _MM_FROUND_CUR_DIRECTION);
2660 }
2661
2662 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2663 _mm512_mask_fmsubadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
2664 return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
2665 (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
2666 _MM_FROUND_CUR_DIRECTION);
2667 }
2668
2669 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2670 _mm512_maskz_fmsubadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
2671 return (__m512h)__builtin_ia32_vfmaddsubph512_maskz(
2672 (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
2673 _MM_FROUND_CUR_DIRECTION);
2674 }
2675
2676 #define _mm512_mask3_fmsub_round_ph(A, B, C, U, R) \
2677 ((__m512h)__builtin_ia32_vfmsubph512_mask3( \
2678 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2679 (__mmask32)(U), (int)(R)))
2680
2681 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2682 _mm512_mask3_fmsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
2683 return (__m512h)__builtin_ia32_vfmsubph512_mask3((__v32hf)__A, (__v32hf)__B,
2684 (__v32hf)__C, (__mmask32)__U,
2685 _MM_FROUND_CUR_DIRECTION);
2686 }
2687
2688 #define _mm512_mask3_fmsubadd_round_ph(A, B, C, U, R) \
2689 ((__m512h)__builtin_ia32_vfmsubaddph512_mask3( \
2690 (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2691 (__mmask32)(U), (int)(R)))
2692
2693 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2694 _mm512_mask3_fmsubadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
2695 return (__m512h)__builtin_ia32_vfmsubaddph512_mask3(
2696 (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
2697 _MM_FROUND_CUR_DIRECTION);
2698 }
2699
2700 #define _mm512_mask_fnmadd_round_ph(A, U, B, C, R) \
2701 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2702 (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2703 (__mmask32)(U), (int)(R)))
2704
2705 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2706 _mm512_mask_fnmadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
2707 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
2708 (__v32hf)__C, (__mmask32)__U,
2709 _MM_FROUND_CUR_DIRECTION);
2710 }
2711
2712 #define _mm512_mask_fnmsub_round_ph(A, U, B, C, R) \
2713 ((__m512h)__builtin_ia32_vfmaddph512_mask( \
2714 (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C), \
2715 (__mmask32)(U), (int)(R)))
2716
2717 #define _mm512_mask3_fnmsub_round_ph(A, B, C, U, R) \
2718 ((__m512h)__builtin_ia32_vfmsubph512_mask3( \
2719 -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C), \
2720 (__mmask32)(U), (int)(R)))
2721
2722 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2723 _mm512_mask_fnmsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
2724 return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
2725 -(__v32hf)__C, (__mmask32)__U,
2726 _MM_FROUND_CUR_DIRECTION);
2727 }
2728
2729 static __inline__ __m512h __DEFAULT_FN_ATTRS512
2730 _mm512_mask3_fnmsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
2731 return (__m512h)__builtin_ia32_vfmsubph512_mask3(-(__v32hf)__A, (__v32hf)__B,
2732 (__v32hf)__C, (__mmask32)__U,
2733 _MM_FROUND_CUR_DIRECTION);
2734 }
2735
2736 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmadd_sh(__m128h __W,
2737 __m128h __A,
2738 __m128h __B) {
2739 return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A, (__v8hf)__B,
2740 (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
2741 }
2742
2743 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmadd_sh(__m128h __W,
2744 __mmask8 __U,
2745 __m128h __A,
2746 __m128h __B) {
2747 return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A, (__v8hf)__B,
2748 (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2749 }
2750
2751 #define _mm_fmadd_round_sh(A, B, C, R) \
2752 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2753 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C), \
2754 (__mmask8)-1, (int)(R)))
2755
2756 #define _mm_mask_fmadd_round_sh(W, U, A, B, R) \
2757 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2758 (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), \
2759 (__mmask8)(U), (int)(R)))
2760
2761 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2762 _mm_maskz_fmadd_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2763 return __builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, (__v8hf)__B, (__v8hf)__C,
2764 (__mmask8)__U,
2765 _MM_FROUND_CUR_DIRECTION);
2766 }
2767
2768 #define _mm_maskz_fmadd_round_sh(U, A, B, C, R) \
2769 ((__m128h)__builtin_ia32_vfmaddsh3_maskz( \
2770 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C), \
2771 (__mmask8)(U), (int)(R)))
2772
2773 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2774 _mm_mask3_fmadd_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
2775 return __builtin_ia32_vfmaddsh3_mask3((__v8hf)__W, (__v8hf)__X, (__v8hf)__Y,
2776 (__mmask8)__U,
2777 _MM_FROUND_CUR_DIRECTION);
2778 }
2779
2780 #define _mm_mask3_fmadd_round_sh(W, X, Y, U, R) \
2781 ((__m128h)__builtin_ia32_vfmaddsh3_mask3( \
2782 (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), \
2783 (__mmask8)(U), (int)(R)))
2784
2785 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmsub_sh(__m128h __W,
2786 __m128h __A,
2787 __m128h __B) {
2788 return (__m128h)__builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A,
2789 -(__v8hf)__B, (__mmask8)-1,
2790 _MM_FROUND_CUR_DIRECTION);
2791 }
2792
2793 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmsub_sh(__m128h __W,
2794 __mmask8 __U,
2795 __m128h __A,
2796 __m128h __B) {
2797 return (__m128h)__builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A,
2798 -(__v8hf)__B, (__mmask8)__U,
2799 _MM_FROUND_CUR_DIRECTION);
2800 }
2801
2802 #define _mm_fmsub_round_sh(A, B, C, R) \
2803 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2804 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C), \
2805 (__mmask8)-1, (int)(R)))
2806
2807 #define _mm_mask_fmsub_round_sh(W, U, A, B, R) \
2808 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2809 (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), \
2810 (__mmask8)(U), (int)(R)))
2811
2812 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2813 _mm_maskz_fmsub_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2814 return (__m128h)__builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, (__v8hf)__B,
2815 -(__v8hf)__C, (__mmask8)__U,
2816 _MM_FROUND_CUR_DIRECTION);
2817 }
2818
2819 #define _mm_maskz_fmsub_round_sh(U, A, B, C, R) \
2820 ((__m128h)__builtin_ia32_vfmaddsh3_maskz( \
2821 (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C), \
2822 (__mmask8)(U), (int)R))
2823
2824 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2825 _mm_mask3_fmsub_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
2826 return __builtin_ia32_vfmsubsh3_mask3((__v8hf)__W, (__v8hf)__X, (__v8hf)__Y,
2827 (__mmask8)__U,
2828 _MM_FROUND_CUR_DIRECTION);
2829 }
2830
2831 #define _mm_mask3_fmsub_round_sh(W, X, Y, U, R) \
2832 ((__m128h)__builtin_ia32_vfmsubsh3_mask3( \
2833 (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), \
2834 (__mmask8)(U), (int)(R)))
2835
2836 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fnmadd_sh(__m128h __W,
2837 __m128h __A,
2838 __m128h __B) {
2839 return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, (__v8hf)__B,
2840 (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
2841 }
2842
2843 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2844 _mm_mask_fnmadd_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2845 return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, (__v8hf)__B,
2846 (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2847 }
2848
2849 #define _mm_fnmadd_round_sh(A, B, C, R) \
2850 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2851 (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C), \
2852 (__mmask8)-1, (int)(R)))
2853
2854 #define _mm_mask_fnmadd_round_sh(W, U, A, B, R) \
2855 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2856 (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), \
2857 (__mmask8)(U), (int)(R)))
2858
2859 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2860 _mm_maskz_fnmadd_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2861 return __builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, -(__v8hf)__B, (__v8hf)__C,
2862 (__mmask8)__U,
2863 _MM_FROUND_CUR_DIRECTION);
2864 }
2865
2866 #define _mm_maskz_fnmadd_round_sh(U, A, B, C, R) \
2867 ((__m128h)__builtin_ia32_vfmaddsh3_maskz( \
2868 (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C), \
2869 (__mmask8)(U), (int)(R)))
2870
2871 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2872 _mm_mask3_fnmadd_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
2873 return __builtin_ia32_vfmaddsh3_mask3((__v8hf)__W, -(__v8hf)__X, (__v8hf)__Y,
2874 (__mmask8)__U,
2875 _MM_FROUND_CUR_DIRECTION);
2876 }
2877
2878 #define _mm_mask3_fnmadd_round_sh(W, X, Y, U, R) \
2879 ((__m128h)__builtin_ia32_vfmaddsh3_mask3( \
2880 (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), \
2881 (__mmask8)(U), (int)(R)))
2882
2883 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fnmsub_sh(__m128h __W,
2884 __m128h __A,
2885 __m128h __B) {
2886 return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, -(__v8hf)__B,
2887 (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
2888 }
2889
2890 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2891 _mm_mask_fnmsub_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
2892 return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, -(__v8hf)__B,
2893 (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
2894 }
2895
2896 #define _mm_fnmsub_round_sh(A, B, C, R) \
2897 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2898 (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C), \
2899 (__mmask8)-1, (int)(R)))
2900
2901 #define _mm_mask_fnmsub_round_sh(W, U, A, B, R) \
2902 ((__m128h)__builtin_ia32_vfmaddsh3_mask( \
2903 (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), \
2904 (__mmask8)(U), (int)(R)))
2905
2906 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2907 _mm_maskz_fnmsub_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2908 return __builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, -(__v8hf)__B, -(__v8hf)__C,
2909 (__mmask8)__U,
2910 _MM_FROUND_CUR_DIRECTION);
2911 }
2912
2913 #define _mm_maskz_fnmsub_round_sh(U, A, B, C, R) \
2914 ((__m128h)__builtin_ia32_vfmaddsh3_maskz( \
2915 (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C), \
2916 (__mmask8)(U), (int)(R)))
2917
2918 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2919 _mm_mask3_fnmsub_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
2920 return __builtin_ia32_vfmsubsh3_mask3((__v8hf)__W, -(__v8hf)__X, (__v8hf)__Y,
2921 (__mmask8)__U,
2922 _MM_FROUND_CUR_DIRECTION);
2923 }
2924
2925 #define _mm_mask3_fnmsub_round_sh(W, X, Y, U, R) \
2926 ((__m128h)__builtin_ia32_vfmsubsh3_mask3( \
2927 (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), \
2928 (__mmask8)(U), (int)(R)))
2929
2930 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fcmadd_sch(__m128h __A,
2931 __m128h __B,
2932 __m128h __C) {
2933 return (__m128h)__builtin_ia32_vfcmaddcsh_mask((__v4sf)__A, (__v4sf)__B,
2934 (__v4sf)__C, (__mmask8)-1,
2935 _MM_FROUND_CUR_DIRECTION);
2936 }
2937
2938 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2939 _mm_mask_fcmadd_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2940 return (__m128h)__builtin_ia32_vfcmaddcsh_round_mask(
2941 (__v4sf)__A, (__v4sf)(__B), (__v4sf)(__C), __U, _MM_FROUND_CUR_DIRECTION);
2942 }
2943
2944 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2945 _mm_maskz_fcmadd_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2946 return (__m128h)__builtin_ia32_vfcmaddcsh_maskz((__v4sf)__A, (__v4sf)__B,
2947 (__v4sf)__C, (__mmask8)__U,
2948 _MM_FROUND_CUR_DIRECTION);
2949 }
2950
2951 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2952 _mm_mask3_fcmadd_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
2953 return (__m128h)__builtin_ia32_vfcmaddcsh_round_mask3(
2954 (__v4sf)__A, (__v4sf)__B, (__v4sf)__C, __U, _MM_FROUND_CUR_DIRECTION);
2955 }
2956
2957 #define _mm_fcmadd_round_sch(A, B, C, R) \
2958 ((__m128h)__builtin_ia32_vfcmaddcsh_mask( \
2959 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
2960 (__mmask8)-1, (int)(R)))
2961
2962 #define _mm_mask_fcmadd_round_sch(A, U, B, C, R) \
2963 ((__m128h)__builtin_ia32_vfcmaddcsh_round_mask( \
2964 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
2965 (__mmask8)(U), (int)(R)))
2966
2967 #define _mm_maskz_fcmadd_round_sch(U, A, B, C, R) \
2968 ((__m128h)__builtin_ia32_vfcmaddcsh_maskz( \
2969 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
2970 (__mmask8)(U), (int)(R)))
2971
2972 #define _mm_mask3_fcmadd_round_sch(A, B, C, U, R) \
2973 ((__m128h)__builtin_ia32_vfcmaddcsh_round_mask3( \
2974 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
2975 (__mmask8)(U), (int)(R)))
2976
2977 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmadd_sch(__m128h __A,
2978 __m128h __B,
2979 __m128h __C) {
2980 return (__m128h)__builtin_ia32_vfmaddcsh_mask((__v4sf)__A, (__v4sf)__B,
2981 (__v4sf)__C, (__mmask8)-1,
2982 _MM_FROUND_CUR_DIRECTION);
2983 }
2984
2985 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2986 _mm_mask_fmadd_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
2987 return (__m128h)__builtin_ia32_vfmaddcsh_round_mask(
2988 (__v4sf)__A, (__v4sf)(__B), (__v4sf)(__C), __U, _MM_FROUND_CUR_DIRECTION);
2989 }
2990
2991 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2992 _mm_maskz_fmadd_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
2993 return (__m128h)__builtin_ia32_vfmaddcsh_maskz((__v4sf)__A, (__v4sf)__B,
2994 (__v4sf)__C, (__mmask8)__U,
2995 _MM_FROUND_CUR_DIRECTION);
2996 }
2997
2998 static __inline__ __m128h __DEFAULT_FN_ATTRS128
2999 _mm_mask3_fmadd_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
3000 return (__m128h)__builtin_ia32_vfmaddcsh_round_mask3(
3001 (__v4sf)__A, (__v4sf)__B, (__v4sf)__C, __U, _MM_FROUND_CUR_DIRECTION);
3002 }
3003
3004 #define _mm_fmadd_round_sch(A, B, C, R) \
3005 ((__m128h)__builtin_ia32_vfmaddcsh_mask( \
3006 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
3007 (__mmask8)-1, (int)(R)))
3008
3009 #define _mm_mask_fmadd_round_sch(A, U, B, C, R) \
3010 ((__m128h)__builtin_ia32_vfmaddcsh_round_mask( \
3011 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
3012 (__mmask8)(U), (int)(R)))
3013
3014 #define _mm_maskz_fmadd_round_sch(U, A, B, C, R) \
3015 ((__m128h)__builtin_ia32_vfmaddcsh_maskz( \
3016 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
3017 (__mmask8)(U), (int)(R)))
3018
3019 #define _mm_mask3_fmadd_round_sch(A, B, C, U, R) \
3020 ((__m128h)__builtin_ia32_vfmaddcsh_round_mask3( \
3021 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C), \
3022 (__mmask8)(U), (int)(R)))
3023
3024 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fcmul_sch(__m128h __A,
3025 __m128h __B) {
3026 return (__m128h)__builtin_ia32_vfcmulcsh_mask(
3027 (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_undefined_ph(), (__mmask8)-1,
3028 _MM_FROUND_CUR_DIRECTION);
3029 }
3030
3031 static __inline__ __m128h __DEFAULT_FN_ATTRS128
3032 _mm_mask_fcmul_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
3033 return (__m128h)__builtin_ia32_vfcmulcsh_mask((__v4sf)__A, (__v4sf)__B,
3034 (__v4sf)__W, (__mmask8)__U,
3035 _MM_FROUND_CUR_DIRECTION);
3036 }
3037
3038 static __inline__ __m128h __DEFAULT_FN_ATTRS128
3039 _mm_maskz_fcmul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
3040 return (__m128h)__builtin_ia32_vfcmulcsh_mask(
3041 (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_setzero_ph(), (__mmask8)__U,
3042 _MM_FROUND_CUR_DIRECTION);
3043 }
3044
3045 #define _mm_fcmul_round_sch(A, B, R) \
3046 ((__m128h)__builtin_ia32_vfcmulcsh_mask( \
3047 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), \
3048 (__v4sf)(__m128h)_mm_undefined_ph(), (__mmask8)-1, (int)(R)))
3049
3050 #define _mm_mask_fcmul_round_sch(W, U, A, B, R) \
3051 ((__m128h)__builtin_ia32_vfcmulcsh_mask( \
3052 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(W), \
3053 (__mmask8)(U), (int)(R)))
3054
3055 #define _mm_maskz_fcmul_round_sch(U, A, B, R) \
3056 ((__m128h)__builtin_ia32_vfcmulcsh_mask( \
3057 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), \
3058 (__v4sf)(__m128h)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
3059
3060 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmul_sch(__m128h __A,
3061 __m128h __B) {
3062 return (__m128h)__builtin_ia32_vfmulcsh_mask(
3063 (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_undefined_ph(), (__mmask8)-1,
3064 _MM_FROUND_CUR_DIRECTION);
3065 }
3066
3067 static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmul_sch(__m128h __W,
3068 __mmask8 __U,
3069 __m128h __A,
3070 __m128h __B) {
3071 return (__m128h)__builtin_ia32_vfmulcsh_mask((__v4sf)__A, (__v4sf)__B,
3072 (__v4sf)__W, (__mmask8)__U,
3073 _MM_FROUND_CUR_DIRECTION);
3074 }
3075
3076 static __inline__ __m128h __DEFAULT_FN_ATTRS128
3077 _mm_maskz_fmul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
3078 return (__m128h)__builtin_ia32_vfmulcsh_mask(
3079 (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_setzero_ph(), (__mmask8)__U,
3080 _MM_FROUND_CUR_DIRECTION);
3081 }
3082
3083 #define _mm_fmul_round_sch(A, B, R) \
3084 ((__m128h)__builtin_ia32_vfmulcsh_mask( \
3085 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), \
3086 (__v4sf)(__m128h)_mm_undefined_ph(), (__mmask8)-1, (int)(R)))
3087
3088 #define _mm_mask_fmul_round_sch(W, U, A, B, R) \
3089 ((__m128h)__builtin_ia32_vfmulcsh_mask( \
3090 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(W), \
3091 (__mmask8)(U), (int)(R)))
3092
3093 #define _mm_maskz_fmul_round_sch(U, A, B, R) \
3094 ((__m128h)__builtin_ia32_vfmulcsh_mask( \
3095 (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), \
3096 (__v4sf)(__m128h)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
3097
3098 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fcmul_pch(__m512h __A,
3099 __m512h __B) {
3100 return (__m512h)__builtin_ia32_vfcmulcph512_mask(
3101 (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_undefined_ph(), (__mmask16)-1,
3102 _MM_FROUND_CUR_DIRECTION);
3103 }
3104
3105 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3106 _mm512_mask_fcmul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
3107 return (__m512h)__builtin_ia32_vfcmulcph512_mask((__v16sf)__A, (__v16sf)__B,
3108 (__v16sf)__W, (__mmask16)__U,
3109 _MM_FROUND_CUR_DIRECTION);
3110 }
3111
3112 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3113 _mm512_maskz_fcmul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
3114 return (__m512h)__builtin_ia32_vfcmulcph512_mask(
3115 (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_setzero_ph(), (__mmask16)__U,
3116 _MM_FROUND_CUR_DIRECTION);
3117 }
3118
3119 #define _mm512_fcmul_round_pch(A, B, R) \
3120 ((__m512h)__builtin_ia32_vfcmulcph512_mask( \
3121 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), \
3122 (__v16sf)(__m512h)_mm512_undefined_ph(), (__mmask16)-1, (int)(R)))
3123
3124 #define _mm512_mask_fcmul_round_pch(W, U, A, B, R) \
3125 ((__m512h)__builtin_ia32_vfcmulcph512_mask( \
3126 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(W), \
3127 (__mmask16)(U), (int)(R)))
3128
3129 #define _mm512_maskz_fcmul_round_pch(U, A, B, R) \
3130 ((__m512h)__builtin_ia32_vfcmulcph512_mask( \
3131 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), \
3132 (__v16sf)(__m512h)_mm512_setzero_ph(), (__mmask16)(U), (int)(R)))
3133
3134 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmul_pch(__m512h __A,
3135 __m512h __B) {
3136 return (__m512h)__builtin_ia32_vfmulcph512_mask(
3137 (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_undefined_ph(), (__mmask16)-1,
3138 _MM_FROUND_CUR_DIRECTION);
3139 }
3140
3141 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3142 _mm512_mask_fmul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
3143 return (__m512h)__builtin_ia32_vfmulcph512_mask((__v16sf)__A, (__v16sf)__B,
3144 (__v16sf)__W, (__mmask16)__U,
3145 _MM_FROUND_CUR_DIRECTION);
3146 }
3147
3148 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3149 _mm512_maskz_fmul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
3150 return (__m512h)__builtin_ia32_vfmulcph512_mask(
3151 (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_setzero_ph(), (__mmask16)__U,
3152 _MM_FROUND_CUR_DIRECTION);
3153 }
3154
3155 #define _mm512_fmul_round_pch(A, B, R) \
3156 ((__m512h)__builtin_ia32_vfmulcph512_mask( \
3157 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), \
3158 (__v16sf)(__m512h)_mm512_undefined_ph(), (__mmask16)-1, (int)(R)))
3159
3160 #define _mm512_mask_fmul_round_pch(W, U, A, B, R) \
3161 ((__m512h)__builtin_ia32_vfmulcph512_mask( \
3162 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(W), \
3163 (__mmask16)(U), (int)(R)))
3164
3165 #define _mm512_maskz_fmul_round_pch(U, A, B, R) \
3166 ((__m512h)__builtin_ia32_vfmulcph512_mask( \
3167 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), \
3168 (__v16sf)(__m512h)_mm512_setzero_ph(), (__mmask16)(U), (int)(R)))
3169
3170 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fcmadd_pch(__m512h __A,
3171 __m512h __B,
3172 __m512h __C) {
3173 return (__m512h)__builtin_ia32_vfcmaddcph512_mask3(
3174 (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)-1,
3175 _MM_FROUND_CUR_DIRECTION);
3176 }
3177
3178 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3179 _mm512_mask_fcmadd_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
3180 return (__m512h)__builtin_ia32_vfcmaddcph512_mask(
3181 (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
3182 _MM_FROUND_CUR_DIRECTION);
3183 }
3184
3185 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3186 _mm512_mask3_fcmadd_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
3187 return (__m512h)__builtin_ia32_vfcmaddcph512_mask3(
3188 (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
3189 _MM_FROUND_CUR_DIRECTION);
3190 }
3191
3192 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3193 _mm512_maskz_fcmadd_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
3194 return (__m512h)__builtin_ia32_vfcmaddcph512_maskz(
3195 (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
3196 _MM_FROUND_CUR_DIRECTION);
3197 }
3198
3199 #define _mm512_fcmadd_round_pch(A, B, C, R) \
3200 ((__m512h)__builtin_ia32_vfcmaddcph512_mask3( \
3201 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3202 (__mmask16)-1, (int)(R)))
3203
3204 #define _mm512_mask_fcmadd_round_pch(A, U, B, C, R) \
3205 ((__m512h)__builtin_ia32_vfcmaddcph512_mask( \
3206 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3207 (__mmask16)(U), (int)(R)))
3208
3209 #define _mm512_mask3_fcmadd_round_pch(A, B, C, U, R) \
3210 ((__m512h)__builtin_ia32_vfcmaddcph512_mask3( \
3211 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3212 (__mmask16)(U), (int)(R)))
3213
3214 #define _mm512_maskz_fcmadd_round_pch(U, A, B, C, R) \
3215 ((__m512h)__builtin_ia32_vfcmaddcph512_maskz( \
3216 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3217 (__mmask16)(U), (int)(R)))
3218
3219 static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmadd_pch(__m512h __A,
3220 __m512h __B,
3221 __m512h __C) {
3222 return (__m512h)__builtin_ia32_vfmaddcph512_mask3((__v16sf)__A, (__v16sf)__B,
3223 (__v16sf)__C, (__mmask16)-1,
3224 _MM_FROUND_CUR_DIRECTION);
3225 }
3226
3227 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3228 _mm512_mask_fmadd_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
3229 return (__m512h)__builtin_ia32_vfmaddcph512_mask((__v16sf)__A, (__v16sf)__B,
3230 (__v16sf)__C, (__mmask16)__U,
3231 _MM_FROUND_CUR_DIRECTION);
3232 }
3233
3234 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3235 _mm512_mask3_fmadd_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
3236 return (__m512h)__builtin_ia32_vfmaddcph512_mask3(
3237 (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
3238 _MM_FROUND_CUR_DIRECTION);
3239 }
3240
3241 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3242 _mm512_maskz_fmadd_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
3243 return (__m512h)__builtin_ia32_vfmaddcph512_maskz(
3244 (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
3245 _MM_FROUND_CUR_DIRECTION);
3246 }
3247
3248 #define _mm512_fmadd_round_pch(A, B, C, R) \
3249 ((__m512h)__builtin_ia32_vfmaddcph512_mask3( \
3250 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3251 (__mmask16)-1, (int)(R)))
3252
3253 #define _mm512_mask_fmadd_round_pch(A, U, B, C, R) \
3254 ((__m512h)__builtin_ia32_vfmaddcph512_mask( \
3255 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3256 (__mmask16)(U), (int)(R)))
3257
3258 #define _mm512_mask3_fmadd_round_pch(A, B, C, U, R) \
3259 ((__m512h)__builtin_ia32_vfmaddcph512_mask3( \
3260 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3261 (__mmask16)(U), (int)(R)))
3262
3263 #define _mm512_maskz_fmadd_round_pch(U, A, B, C, R) \
3264 ((__m512h)__builtin_ia32_vfmaddcph512_maskz( \
3265 (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C), \
3266 (__mmask16)(U), (int)(R)))
3267
3268 static __inline__ _Float16 __DEFAULT_FN_ATTRS512
3269 _mm512_reduce_add_ph(__m512h __W) {
3270 return __builtin_ia32_reduce_fadd_ph512(-0.0f16, __W);
3271 }
3272
3273 static __inline__ _Float16 __DEFAULT_FN_ATTRS512
3274 _mm512_reduce_mul_ph(__m512h __W) {
3275 return __builtin_ia32_reduce_fmul_ph512(1.0f16, __W);
3276 }
3277
3278 static __inline__ _Float16 __DEFAULT_FN_ATTRS512
3279 _mm512_reduce_max_ph(__m512h __V) {
3280 return __builtin_ia32_reduce_fmax_ph512(__V);
3281 }
3282
3283 static __inline__ _Float16 __DEFAULT_FN_ATTRS512
3284 _mm512_reduce_min_ph(__m512h __V) {
3285 return __builtin_ia32_reduce_fmin_ph512(__V);
3286 }
3287
3288 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3289 _mm512_mask_blend_ph(__mmask32 __U, __m512h __A, __m512h __W) {
3290 return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U, (__v32hf)__W,
3291 (__v32hf)__A);
3292 }
3293
3294 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3295 _mm512_permutex2var_ph(__m512h __A, __m512i __I, __m512h __B) {
3296 return (__m512h)__builtin_ia32_vpermi2varhi512((__v32hi)__A, (__v32hi)__I,
3297 (__v32hi)__B);
3298 }
3299
3300 static __inline__ __m512h __DEFAULT_FN_ATTRS512
3301 _mm512_permutexvar_ph(__m512i __A, __m512h __B) {
3302 return (__m512h)__builtin_ia32_permvarhi512((__v32hi)__B, (__v32hi)__A);
3303 }
3304
3305 // intrinsics below are alias for f*mul_*ch
3306 #define _mm512_mul_pch(A, B) _mm512_fmul_pch(A, B)
3307 #define _mm512_mask_mul_pch(W, U, A, B) _mm512_mask_fmul_pch(W, U, A, B)
3308 #define _mm512_maskz_mul_pch(U, A, B) _mm512_maskz_fmul_pch(U, A, B)
3309 #define _mm512_mul_round_pch(A, B, R) _mm512_fmul_round_pch(A, B, R)
3310 #define _mm512_mask_mul_round_pch(W, U, A, B, R) \
3311 _mm512_mask_fmul_round_pch(W, U, A, B, R)
3312 #define _mm512_maskz_mul_round_pch(U, A, B, R) \
3313 _mm512_maskz_fmul_round_pch(U, A, B, R)
3314
3315 #define _mm512_cmul_pch(A, B) _mm512_fcmul_pch(A, B)
3316 #define _mm512_mask_cmul_pch(W, U, A, B) _mm512_mask_fcmul_pch(W, U, A, B)
3317 #define _mm512_maskz_cmul_pch(U, A, B) _mm512_maskz_fcmul_pch(U, A, B)
3318 #define _mm512_cmul_round_pch(A, B, R) _mm512_fcmul_round_pch(A, B, R)
3319 #define _mm512_mask_cmul_round_pch(W, U, A, B, R) \
3320 _mm512_mask_fcmul_round_pch(W, U, A, B, R)
3321 #define _mm512_maskz_cmul_round_pch(U, A, B, R) \
3322 _mm512_maskz_fcmul_round_pch(U, A, B, R)
3323
3324 #define _mm_mul_sch(A, B) _mm_fmul_sch(A, B)
3325 #define _mm_mask_mul_sch(W, U, A, B) _mm_mask_fmul_sch(W, U, A, B)
3326 #define _mm_maskz_mul_sch(U, A, B) _mm_maskz_fmul_sch(U, A, B)
3327 #define _mm_mul_round_sch(A, B, R) _mm_fmul_round_sch(A, B, R)
3328 #define _mm_mask_mul_round_sch(W, U, A, B, R) \
3329 _mm_mask_fmul_round_sch(W, U, A, B, R)
3330 #define _mm_maskz_mul_round_sch(U, A, B, R) _mm_maskz_fmul_round_sch(U, A, B, R)
3331
3332 #define _mm_cmul_sch(A, B) _mm_fcmul_sch(A, B)
3333 #define _mm_mask_cmul_sch(W, U, A, B) _mm_mask_fcmul_sch(W, U, A, B)
3334 #define _mm_maskz_cmul_sch(U, A, B) _mm_maskz_fcmul_sch(U, A, B)
3335 #define _mm_cmul_round_sch(A, B, R) _mm_fcmul_round_sch(A, B, R)
3336 #define _mm_mask_cmul_round_sch(W, U, A, B, R) \
3337 _mm_mask_fcmul_round_sch(W, U, A, B, R)
3338 #define _mm_maskz_cmul_round_sch(U, A, B, R) \
3339 _mm_maskz_fcmul_round_sch(U, A, B, R)
3340
3341 #undef __DEFAULT_FN_ATTRS128
3342 #undef __DEFAULT_FN_ATTRS256
3343 #undef __DEFAULT_FN_ATTRS512
3344
3345 #endif
3346 #endif
LLVM monorepo