1use crate::{
2 arch::asm,
3 core_arch::{simd::*, x86::*},
4 intrinsics::fma,
5 intrinsics::simd::*,
6 mem, ptr,
7};
8
9use core::hint::unreachable_unchecked;
10#[cfg(test)]
11use stdarch_test::assert_instr;
12
13#[inline]
17#[target_feature(enable = "avx512f")]
18#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19#[cfg_attr(test, assert_instr(vpabsd))]
20#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21pub const fn _mm512_abs_epi32(a: __m512i) -> __m512i {
22 unsafe {
23 let a = a.as_i32x16();
24 let r = simd_select::<i32x16, _>(simd_lt(a, i32x16::ZERO), simd_neg(a), a);
25 transmute(r)
26 }
27}
28
29#[inline]
35#[target_feature(enable = "avx512f")]
36#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
37#[cfg_attr(test, assert_instr(vpabsd))]
38#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
39pub const fn _mm512_mask_abs_epi32(src: __m512i, k: __mmask16, a: __m512i) -> __m512i {
40 unsafe {
41 let abs = _mm512_abs_epi32(a).as_i32x16();
42 transmute(simd_select_bitmask(k, abs, src.as_i32x16()))
43 }
44}
45
46#[inline]
52#[target_feature(enable = "avx512f")]
53#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
54#[cfg_attr(test, assert_instr(vpabsd))]
55#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
56pub const fn _mm512_maskz_abs_epi32(k: __mmask16, a: __m512i) -> __m512i {
57 unsafe {
58 let abs = _mm512_abs_epi32(a).as_i32x16();
59 transmute(simd_select_bitmask(k, abs, i32x16::ZERO))
60 }
61}
62
63#[inline]
67#[target_feature(enable = "avx512f,avx512vl")]
68#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
69#[cfg_attr(test, assert_instr(vpabsd))]
70#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
71pub const fn _mm256_mask_abs_epi32(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
72 unsafe {
73 let abs = _mm256_abs_epi32(a).as_i32x8();
74 transmute(simd_select_bitmask(k, abs, src.as_i32x8()))
75 }
76}
77
78#[inline]
82#[target_feature(enable = "avx512f,avx512vl")]
83#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
84#[cfg_attr(test, assert_instr(vpabsd))]
85#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
86pub const fn _mm256_maskz_abs_epi32(k: __mmask8, a: __m256i) -> __m256i {
87 unsafe {
88 let abs = _mm256_abs_epi32(a).as_i32x8();
89 transmute(simd_select_bitmask(k, abs, i32x8::ZERO))
90 }
91}
92
93#[inline]
97#[target_feature(enable = "avx512f,avx512vl")]
98#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
99#[cfg_attr(test, assert_instr(vpabsd))]
100#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
101pub const fn _mm_mask_abs_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
102 unsafe {
103 let abs = _mm_abs_epi32(a).as_i32x4();
104 transmute(simd_select_bitmask(k, abs, src.as_i32x4()))
105 }
106}
107
108#[inline]
112#[target_feature(enable = "avx512f,avx512vl")]
113#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
114#[cfg_attr(test, assert_instr(vpabsd))]
115#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
116pub const fn _mm_maskz_abs_epi32(k: __mmask8, a: __m128i) -> __m128i {
117 unsafe {
118 let abs = _mm_abs_epi32(a).as_i32x4();
119 transmute(simd_select_bitmask(k, abs, i32x4::ZERO))
120 }
121}
122
123#[inline]
127#[target_feature(enable = "avx512f")]
128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
129#[cfg_attr(test, assert_instr(vpabsq))]
130#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
131pub const fn _mm512_abs_epi64(a: __m512i) -> __m512i {
132 unsafe {
133 let a = a.as_i64x8();
134 let r = simd_select::<i64x8, _>(simd_lt(a, i64x8::ZERO), simd_neg(a), a);
135 transmute(r)
136 }
137}
138
139#[inline]
143#[target_feature(enable = "avx512f")]
144#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
145#[cfg_attr(test, assert_instr(vpabsq))]
146#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
147pub const fn _mm512_mask_abs_epi64(src: __m512i, k: __mmask8, a: __m512i) -> __m512i {
148 unsafe {
149 let abs = _mm512_abs_epi64(a).as_i64x8();
150 transmute(simd_select_bitmask(k, abs, src.as_i64x8()))
151 }
152}
153
154#[inline]
158#[target_feature(enable = "avx512f")]
159#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
160#[cfg_attr(test, assert_instr(vpabsq))]
161#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
162pub const fn _mm512_maskz_abs_epi64(k: __mmask8, a: __m512i) -> __m512i {
163 unsafe {
164 let abs = _mm512_abs_epi64(a).as_i64x8();
165 transmute(simd_select_bitmask(k, abs, i64x8::ZERO))
166 }
167}
168
169#[inline]
173#[target_feature(enable = "avx512f,avx512vl")]
174#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
175#[cfg_attr(test, assert_instr(vpabsq))]
176#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
177pub const fn _mm256_abs_epi64(a: __m256i) -> __m256i {
178 unsafe {
179 let a = a.as_i64x4();
180 let r = simd_select::<i64x4, _>(simd_lt(a, i64x4::ZERO), simd_neg(a), a);
181 transmute(r)
182 }
183}
184
185#[inline]
189#[target_feature(enable = "avx512f,avx512vl")]
190#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
191#[cfg_attr(test, assert_instr(vpabsq))]
192#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
193pub const fn _mm256_mask_abs_epi64(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
194 unsafe {
195 let abs = _mm256_abs_epi64(a).as_i64x4();
196 transmute(simd_select_bitmask(k, abs, src.as_i64x4()))
197 }
198}
199
200#[inline]
204#[target_feature(enable = "avx512f,avx512vl")]
205#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
206#[cfg_attr(test, assert_instr(vpabsq))]
207#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
208pub const fn _mm256_maskz_abs_epi64(k: __mmask8, a: __m256i) -> __m256i {
209 unsafe {
210 let abs = _mm256_abs_epi64(a).as_i64x4();
211 transmute(simd_select_bitmask(k, abs, i64x4::ZERO))
212 }
213}
214
215#[inline]
219#[target_feature(enable = "avx512f,avx512vl")]
220#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
221#[cfg_attr(test, assert_instr(vpabsq))]
222#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
223pub const fn _mm_abs_epi64(a: __m128i) -> __m128i {
224 unsafe {
225 let a = a.as_i64x2();
226 let r = simd_select::<i64x2, _>(simd_lt(a, i64x2::ZERO), simd_neg(a), a);
227 transmute(r)
228 }
229}
230
231#[inline]
235#[target_feature(enable = "avx512f,avx512vl")]
236#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
237#[cfg_attr(test, assert_instr(vpabsq))]
238#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
239pub const fn _mm_mask_abs_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
240 unsafe {
241 let abs = _mm_abs_epi64(a).as_i64x2();
242 transmute(simd_select_bitmask(k, abs, src.as_i64x2()))
243 }
244}
245
246#[inline]
250#[target_feature(enable = "avx512f,avx512vl")]
251#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
252#[cfg_attr(test, assert_instr(vpabsq))]
253#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
254pub const fn _mm_maskz_abs_epi64(k: __mmask8, a: __m128i) -> __m128i {
255 unsafe {
256 let abs = _mm_abs_epi64(a).as_i64x2();
257 transmute(simd_select_bitmask(k, abs, i64x2::ZERO))
258 }
259}
260
261#[inline]
265#[target_feature(enable = "avx512f")]
266#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
267#[cfg_attr(test, assert_instr(vpandd))]
268#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
269pub const fn _mm512_abs_ps(v2: __m512) -> __m512 {
270 unsafe { simd_fabs(v2) }
271}
272
273#[inline]
277#[target_feature(enable = "avx512f")]
278#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
279#[cfg_attr(test, assert_instr(vpandd))]
280#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
281pub const fn _mm512_mask_abs_ps(src: __m512, k: __mmask16, v2: __m512) -> __m512 {
282 unsafe { simd_select_bitmask(k, simd_fabs(v2), src) }
283}
284
285#[inline]
289#[target_feature(enable = "avx512f")]
290#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
291#[cfg_attr(test, assert_instr(vpandq))]
292#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
293pub const fn _mm512_abs_pd(v2: __m512d) -> __m512d {
294 unsafe { simd_fabs(v2) }
295}
296
297#[inline]
301#[target_feature(enable = "avx512f")]
302#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
303#[cfg_attr(test, assert_instr(vpandq))]
304#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
305pub const fn _mm512_mask_abs_pd(src: __m512d, k: __mmask8, v2: __m512d) -> __m512d {
306 unsafe { simd_select_bitmask(k, simd_fabs(v2), src) }
307}
308
309#[inline]
313#[target_feature(enable = "avx512f")]
314#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
315#[cfg_attr(test, assert_instr(vmovdqa32))]
316#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
317pub const fn _mm512_mask_mov_epi32(src: __m512i, k: __mmask16, a: __m512i) -> __m512i {
318 unsafe {
319 let mov = a.as_i32x16();
320 transmute(simd_select_bitmask(k, mov, src.as_i32x16()))
321 }
322}
323
324#[inline]
328#[target_feature(enable = "avx512f")]
329#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
330#[cfg_attr(test, assert_instr(vmovdqa32))]
331#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
332pub const fn _mm512_maskz_mov_epi32(k: __mmask16, a: __m512i) -> __m512i {
333 unsafe {
334 let mov = a.as_i32x16();
335 transmute(simd_select_bitmask(k, mov, i32x16::ZERO))
336 }
337}
338
339#[inline]
343#[target_feature(enable = "avx512f,avx512vl")]
344#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
345#[cfg_attr(test, assert_instr(vmovdqa32))]
346#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
347pub const fn _mm256_mask_mov_epi32(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
348 unsafe {
349 let mov = a.as_i32x8();
350 transmute(simd_select_bitmask(k, mov, src.as_i32x8()))
351 }
352}
353
354#[inline]
358#[target_feature(enable = "avx512f,avx512vl")]
359#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
360#[cfg_attr(test, assert_instr(vmovdqa32))]
361#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
362pub const fn _mm256_maskz_mov_epi32(k: __mmask8, a: __m256i) -> __m256i {
363 unsafe {
364 let mov = a.as_i32x8();
365 transmute(simd_select_bitmask(k, mov, i32x8::ZERO))
366 }
367}
368
369#[inline]
373#[target_feature(enable = "avx512f,avx512vl")]
374#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
375#[cfg_attr(test, assert_instr(vmovdqa32))]
376#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
377pub const fn _mm_mask_mov_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
378 unsafe {
379 let mov = a.as_i32x4();
380 transmute(simd_select_bitmask(k, mov, src.as_i32x4()))
381 }
382}
383
384#[inline]
388#[target_feature(enable = "avx512f,avx512vl")]
389#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
390#[cfg_attr(test, assert_instr(vmovdqa32))]
391#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
392pub const fn _mm_maskz_mov_epi32(k: __mmask8, a: __m128i) -> __m128i {
393 unsafe {
394 let mov = a.as_i32x4();
395 transmute(simd_select_bitmask(k, mov, i32x4::ZERO))
396 }
397}
398
399#[inline]
403#[target_feature(enable = "avx512f")]
404#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
405#[cfg_attr(test, assert_instr(vmovdqa64))]
406#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
407pub const fn _mm512_mask_mov_epi64(src: __m512i, k: __mmask8, a: __m512i) -> __m512i {
408 unsafe {
409 let mov = a.as_i64x8();
410 transmute(simd_select_bitmask(k, mov, src.as_i64x8()))
411 }
412}
413
414#[inline]
418#[target_feature(enable = "avx512f")]
419#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
420#[cfg_attr(test, assert_instr(vmovdqa64))]
421#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
422pub const fn _mm512_maskz_mov_epi64(k: __mmask8, a: __m512i) -> __m512i {
423 unsafe {
424 let mov = a.as_i64x8();
425 transmute(simd_select_bitmask(k, mov, i64x8::ZERO))
426 }
427}
428
429#[inline]
433#[target_feature(enable = "avx512f,avx512vl")]
434#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
435#[cfg_attr(test, assert_instr(vmovdqa64))]
436#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
437pub const fn _mm256_mask_mov_epi64(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
438 unsafe {
439 let mov = a.as_i64x4();
440 transmute(simd_select_bitmask(k, mov, src.as_i64x4()))
441 }
442}
443
444#[inline]
448#[target_feature(enable = "avx512f,avx512vl")]
449#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
450#[cfg_attr(test, assert_instr(vmovdqa64))]
451#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
452pub const fn _mm256_maskz_mov_epi64(k: __mmask8, a: __m256i) -> __m256i {
453 unsafe {
454 let mov = a.as_i64x4();
455 transmute(simd_select_bitmask(k, mov, i64x4::ZERO))
456 }
457}
458
459#[inline]
463#[target_feature(enable = "avx512f,avx512vl")]
464#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
465#[cfg_attr(test, assert_instr(vmovdqa64))]
466#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
467pub const fn _mm_mask_mov_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
468 unsafe {
469 let mov = a.as_i64x2();
470 transmute(simd_select_bitmask(k, mov, src.as_i64x2()))
471 }
472}
473
474#[inline]
478#[target_feature(enable = "avx512f,avx512vl")]
479#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
480#[cfg_attr(test, assert_instr(vmovdqa64))]
481#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
482pub const fn _mm_maskz_mov_epi64(k: __mmask8, a: __m128i) -> __m128i {
483 unsafe {
484 let mov = a.as_i64x2();
485 transmute(simd_select_bitmask(k, mov, i64x2::ZERO))
486 }
487}
488
489#[inline]
493#[target_feature(enable = "avx512f")]
494#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
495#[cfg_attr(test, assert_instr(vmovaps))]
496#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
497pub const fn _mm512_mask_mov_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
498 unsafe {
499 let mov = a.as_f32x16();
500 transmute(simd_select_bitmask(k, mov, src.as_f32x16()))
501 }
502}
503
504#[inline]
508#[target_feature(enable = "avx512f")]
509#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
510#[cfg_attr(test, assert_instr(vmovaps))]
511#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
512pub const fn _mm512_maskz_mov_ps(k: __mmask16, a: __m512) -> __m512 {
513 unsafe {
514 let mov = a.as_f32x16();
515 transmute(simd_select_bitmask(k, mov, f32x16::ZERO))
516 }
517}
518
519#[inline]
523#[target_feature(enable = "avx512f,avx512vl")]
524#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
525#[cfg_attr(test, assert_instr(vmovaps))]
526#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
527pub const fn _mm256_mask_mov_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
528 unsafe {
529 let mov = a.as_f32x8();
530 transmute(simd_select_bitmask(k, mov, src.as_f32x8()))
531 }
532}
533
534#[inline]
538#[target_feature(enable = "avx512f,avx512vl")]
539#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
540#[cfg_attr(test, assert_instr(vmovaps))]
541#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
542pub const fn _mm256_maskz_mov_ps(k: __mmask8, a: __m256) -> __m256 {
543 unsafe {
544 let mov = a.as_f32x8();
545 transmute(simd_select_bitmask(k, mov, f32x8::ZERO))
546 }
547}
548
549#[inline]
553#[target_feature(enable = "avx512f,avx512vl")]
554#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
555#[cfg_attr(test, assert_instr(vmovaps))]
556#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
557pub const fn _mm_mask_mov_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
558 unsafe {
559 let mov = a.as_f32x4();
560 transmute(simd_select_bitmask(k, mov, src.as_f32x4()))
561 }
562}
563
564#[inline]
568#[target_feature(enable = "avx512f,avx512vl")]
569#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
570#[cfg_attr(test, assert_instr(vmovaps))]
571#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
572pub const fn _mm_maskz_mov_ps(k: __mmask8, a: __m128) -> __m128 {
573 unsafe {
574 let mov = a.as_f32x4();
575 transmute(simd_select_bitmask(k, mov, f32x4::ZERO))
576 }
577}
578
579#[inline]
583#[target_feature(enable = "avx512f")]
584#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
585#[cfg_attr(test, assert_instr(vmovapd))]
586#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
587pub const fn _mm512_mask_mov_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
588 unsafe {
589 let mov = a.as_f64x8();
590 transmute(simd_select_bitmask(k, mov, src.as_f64x8()))
591 }
592}
593
594#[inline]
598#[target_feature(enable = "avx512f")]
599#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
600#[cfg_attr(test, assert_instr(vmovapd))]
601#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
602pub const fn _mm512_maskz_mov_pd(k: __mmask8, a: __m512d) -> __m512d {
603 unsafe {
604 let mov = a.as_f64x8();
605 transmute(simd_select_bitmask(k, mov, f64x8::ZERO))
606 }
607}
608
609#[inline]
613#[target_feature(enable = "avx512f,avx512vl")]
614#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
615#[cfg_attr(test, assert_instr(vmovapd))]
616#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
617pub const fn _mm256_mask_mov_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
618 unsafe {
619 let mov = a.as_f64x4();
620 transmute(simd_select_bitmask(k, mov, src.as_f64x4()))
621 }
622}
623
624#[inline]
628#[target_feature(enable = "avx512f,avx512vl")]
629#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
630#[cfg_attr(test, assert_instr(vmovapd))]
631#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
632pub const fn _mm256_maskz_mov_pd(k: __mmask8, a: __m256d) -> __m256d {
633 unsafe {
634 let mov = a.as_f64x4();
635 transmute(simd_select_bitmask(k, mov, f64x4::ZERO))
636 }
637}
638
639#[inline]
643#[target_feature(enable = "avx512f,avx512vl")]
644#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
645#[cfg_attr(test, assert_instr(vmovapd))]
646#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
647pub const fn _mm_mask_mov_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
648 unsafe {
649 let mov = a.as_f64x2();
650 transmute(simd_select_bitmask(k, mov, src.as_f64x2()))
651 }
652}
653
654#[inline]
658#[target_feature(enable = "avx512f,avx512vl")]
659#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
660#[cfg_attr(test, assert_instr(vmovapd))]
661#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
662pub const fn _mm_maskz_mov_pd(k: __mmask8, a: __m128d) -> __m128d {
663 unsafe {
664 let mov = a.as_f64x2();
665 transmute(simd_select_bitmask(k, mov, f64x2::ZERO))
666 }
667}
668
669#[inline]
673#[target_feature(enable = "avx512f")]
674#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
675#[cfg_attr(test, assert_instr(vpaddd))]
676#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
677pub const fn _mm512_add_epi32(a: __m512i, b: __m512i) -> __m512i {
678 unsafe { transmute(simd_add(a.as_i32x16(), b.as_i32x16())) }
679}
680
681#[inline]
685#[target_feature(enable = "avx512f")]
686#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
687#[cfg_attr(test, assert_instr(vpaddd))]
688#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
689pub const fn _mm512_mask_add_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
690 unsafe {
691 let add = _mm512_add_epi32(a, b).as_i32x16();
692 transmute(simd_select_bitmask(k, add, src.as_i32x16()))
693 }
694}
695
696#[inline]
700#[target_feature(enable = "avx512f")]
701#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
702#[cfg_attr(test, assert_instr(vpaddd))]
703#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
704pub const fn _mm512_maskz_add_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
705 unsafe {
706 let add = _mm512_add_epi32(a, b).as_i32x16();
707 transmute(simd_select_bitmask(k, add, i32x16::ZERO))
708 }
709}
710
711#[inline]
715#[target_feature(enable = "avx512f,avx512vl")]
716#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
717#[cfg_attr(test, assert_instr(vpaddd))]
718#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
719pub const fn _mm256_mask_add_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
720 unsafe {
721 let add = _mm256_add_epi32(a, b).as_i32x8();
722 transmute(simd_select_bitmask(k, add, src.as_i32x8()))
723 }
724}
725
726#[inline]
730#[target_feature(enable = "avx512f,avx512vl")]
731#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
732#[cfg_attr(test, assert_instr(vpaddd))]
733#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
734pub const fn _mm256_maskz_add_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
735 unsafe {
736 let add = _mm256_add_epi32(a, b).as_i32x8();
737 transmute(simd_select_bitmask(k, add, i32x8::ZERO))
738 }
739}
740
741#[inline]
745#[target_feature(enable = "avx512f,avx512vl")]
746#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
747#[cfg_attr(test, assert_instr(vpaddd))]
748#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
749pub const fn _mm_mask_add_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
750 unsafe {
751 let add = _mm_add_epi32(a, b).as_i32x4();
752 transmute(simd_select_bitmask(k, add, src.as_i32x4()))
753 }
754}
755
756#[inline]
760#[target_feature(enable = "avx512f,avx512vl")]
761#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
762#[cfg_attr(test, assert_instr(vpaddd))]
763#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
764pub const fn _mm_maskz_add_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
765 unsafe {
766 let add = _mm_add_epi32(a, b).as_i32x4();
767 transmute(simd_select_bitmask(k, add, i32x4::ZERO))
768 }
769}
770
771#[inline]
775#[target_feature(enable = "avx512f")]
776#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
777#[cfg_attr(test, assert_instr(vpaddq))]
778#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
779pub const fn _mm512_add_epi64(a: __m512i, b: __m512i) -> __m512i {
780 unsafe { transmute(simd_add(a.as_i64x8(), b.as_i64x8())) }
781}
782
783#[inline]
787#[target_feature(enable = "avx512f")]
788#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
789#[cfg_attr(test, assert_instr(vpaddq))]
790#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
791pub const fn _mm512_mask_add_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
792 unsafe {
793 let add = _mm512_add_epi64(a, b).as_i64x8();
794 transmute(simd_select_bitmask(k, add, src.as_i64x8()))
795 }
796}
797
798#[inline]
802#[target_feature(enable = "avx512f")]
803#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
804#[cfg_attr(test, assert_instr(vpaddq))]
805#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
806pub const fn _mm512_maskz_add_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
807 unsafe {
808 let add = _mm512_add_epi64(a, b).as_i64x8();
809 transmute(simd_select_bitmask(k, add, i64x8::ZERO))
810 }
811}
812
813#[inline]
817#[target_feature(enable = "avx512f,avx512vl")]
818#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
819#[cfg_attr(test, assert_instr(vpaddq))]
820#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
821pub const fn _mm256_mask_add_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
822 unsafe {
823 let add = _mm256_add_epi64(a, b).as_i64x4();
824 transmute(simd_select_bitmask(k, add, src.as_i64x4()))
825 }
826}
827
828#[inline]
832#[target_feature(enable = "avx512f,avx512vl")]
833#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
834#[cfg_attr(test, assert_instr(vpaddq))]
835#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
836pub const fn _mm256_maskz_add_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
837 unsafe {
838 let add = _mm256_add_epi64(a, b).as_i64x4();
839 transmute(simd_select_bitmask(k, add, i64x4::ZERO))
840 }
841}
842
843#[inline]
847#[target_feature(enable = "avx512f,avx512vl")]
848#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
849#[cfg_attr(test, assert_instr(vpaddq))]
850#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
851pub const fn _mm_mask_add_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
852 unsafe {
853 let add = _mm_add_epi64(a, b).as_i64x2();
854 transmute(simd_select_bitmask(k, add, src.as_i64x2()))
855 }
856}
857
858#[inline]
862#[target_feature(enable = "avx512f,avx512vl")]
863#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
864#[cfg_attr(test, assert_instr(vpaddq))]
865#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
866pub const fn _mm_maskz_add_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
867 unsafe {
868 let add = _mm_add_epi64(a, b).as_i64x2();
869 transmute(simd_select_bitmask(k, add, i64x2::ZERO))
870 }
871}
872
873#[inline]
877#[target_feature(enable = "avx512f")]
878#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
879#[cfg_attr(test, assert_instr(vaddps))]
880#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
881pub const fn _mm512_add_ps(a: __m512, b: __m512) -> __m512 {
882 unsafe { transmute(simd_add(a.as_f32x16(), b.as_f32x16())) }
883}
884
885#[inline]
889#[target_feature(enable = "avx512f")]
890#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
891#[cfg_attr(test, assert_instr(vaddps))]
892#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
893pub const fn _mm512_mask_add_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
894 unsafe {
895 let add = _mm512_add_ps(a, b).as_f32x16();
896 transmute(simd_select_bitmask(k, add, src.as_f32x16()))
897 }
898}
899
900#[inline]
904#[target_feature(enable = "avx512f")]
905#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
906#[cfg_attr(test, assert_instr(vaddps))]
907#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
908pub const fn _mm512_maskz_add_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
909 unsafe {
910 let add = _mm512_add_ps(a, b).as_f32x16();
911 transmute(simd_select_bitmask(k, add, f32x16::ZERO))
912 }
913}
914
915#[inline]
919#[target_feature(enable = "avx512f,avx512vl")]
920#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
921#[cfg_attr(test, assert_instr(vaddps))]
922#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
923pub const fn _mm256_mask_add_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
924 unsafe {
925 let add = _mm256_add_ps(a, b).as_f32x8();
926 transmute(simd_select_bitmask(k, add, src.as_f32x8()))
927 }
928}
929
930#[inline]
934#[target_feature(enable = "avx512f,avx512vl")]
935#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
936#[cfg_attr(test, assert_instr(vaddps))]
937#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
938pub const fn _mm256_maskz_add_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
939 unsafe {
940 let add = _mm256_add_ps(a, b).as_f32x8();
941 transmute(simd_select_bitmask(k, add, f32x8::ZERO))
942 }
943}
944
945#[inline]
949#[target_feature(enable = "avx512f,avx512vl")]
950#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
951#[cfg_attr(test, assert_instr(vaddps))]
952#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
953pub const fn _mm_mask_add_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
954 unsafe {
955 let add = _mm_add_ps(a, b).as_f32x4();
956 transmute(simd_select_bitmask(k, add, src.as_f32x4()))
957 }
958}
959
960#[inline]
964#[target_feature(enable = "avx512f,avx512vl")]
965#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
966#[cfg_attr(test, assert_instr(vaddps))]
967#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
968pub const fn _mm_maskz_add_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
969 unsafe {
970 let add = _mm_add_ps(a, b).as_f32x4();
971 transmute(simd_select_bitmask(k, add, f32x4::ZERO))
972 }
973}
974
975#[inline]
979#[target_feature(enable = "avx512f")]
980#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
981#[cfg_attr(test, assert_instr(vaddpd))]
982#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
983pub const fn _mm512_add_pd(a: __m512d, b: __m512d) -> __m512d {
984 unsafe { transmute(simd_add(a.as_f64x8(), b.as_f64x8())) }
985}
986
987#[inline]
991#[target_feature(enable = "avx512f")]
992#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
993#[cfg_attr(test, assert_instr(vaddpd))]
994#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
995pub const fn _mm512_mask_add_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
996 unsafe {
997 let add = _mm512_add_pd(a, b).as_f64x8();
998 transmute(simd_select_bitmask(k, add, src.as_f64x8()))
999 }
1000}
1001
1002#[inline]
1006#[target_feature(enable = "avx512f")]
1007#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1008#[cfg_attr(test, assert_instr(vaddpd))]
1009#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1010pub const fn _mm512_maskz_add_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
1011 unsafe {
1012 let add = _mm512_add_pd(a, b).as_f64x8();
1013 transmute(simd_select_bitmask(k, add, f64x8::ZERO))
1014 }
1015}
1016
1017#[inline]
1021#[target_feature(enable = "avx512f,avx512vl")]
1022#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1023#[cfg_attr(test, assert_instr(vaddpd))]
1024#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1025pub const fn _mm256_mask_add_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
1026 unsafe {
1027 let add = _mm256_add_pd(a, b).as_f64x4();
1028 transmute(simd_select_bitmask(k, add, src.as_f64x4()))
1029 }
1030}
1031
1032#[inline]
1036#[target_feature(enable = "avx512f,avx512vl")]
1037#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1038#[cfg_attr(test, assert_instr(vaddpd))]
1039#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1040pub const fn _mm256_maskz_add_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
1041 unsafe {
1042 let add = _mm256_add_pd(a, b).as_f64x4();
1043 transmute(simd_select_bitmask(k, add, f64x4::ZERO))
1044 }
1045}
1046
1047#[inline]
1051#[target_feature(enable = "avx512f,avx512vl")]
1052#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1053#[cfg_attr(test, assert_instr(vaddpd))]
1054#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1055pub const fn _mm_mask_add_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
1056 unsafe {
1057 let add = _mm_add_pd(a, b).as_f64x2();
1058 transmute(simd_select_bitmask(k, add, src.as_f64x2()))
1059 }
1060}
1061
1062#[inline]
1066#[target_feature(enable = "avx512f,avx512vl")]
1067#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1068#[cfg_attr(test, assert_instr(vaddpd))]
1069#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1070pub const fn _mm_maskz_add_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
1071 unsafe {
1072 let add = _mm_add_pd(a, b).as_f64x2();
1073 transmute(simd_select_bitmask(k, add, f64x2::ZERO))
1074 }
1075}
1076
1077#[inline]
1081#[target_feature(enable = "avx512f")]
1082#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1083#[cfg_attr(test, assert_instr(vpsubd))]
1084#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1085pub const fn _mm512_sub_epi32(a: __m512i, b: __m512i) -> __m512i {
1086 unsafe { transmute(simd_sub(a.as_i32x16(), b.as_i32x16())) }
1087}
1088
1089#[inline]
1093#[target_feature(enable = "avx512f")]
1094#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1095#[cfg_attr(test, assert_instr(vpsubd))]
1096#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1097pub const fn _mm512_mask_sub_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
1098 unsafe {
1099 let sub = _mm512_sub_epi32(a, b).as_i32x16();
1100 transmute(simd_select_bitmask(k, sub, src.as_i32x16()))
1101 }
1102}
1103
1104#[inline]
1108#[target_feature(enable = "avx512f")]
1109#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1110#[cfg_attr(test, assert_instr(vpsubd))]
1111#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1112pub const fn _mm512_maskz_sub_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
1113 unsafe {
1114 let sub = _mm512_sub_epi32(a, b).as_i32x16();
1115 transmute(simd_select_bitmask(k, sub, i32x16::ZERO))
1116 }
1117}
1118
1119#[inline]
1123#[target_feature(enable = "avx512f,avx512vl")]
1124#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1125#[cfg_attr(test, assert_instr(vpsubd))]
1126#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1127pub const fn _mm256_mask_sub_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1128 unsafe {
1129 let sub = _mm256_sub_epi32(a, b).as_i32x8();
1130 transmute(simd_select_bitmask(k, sub, src.as_i32x8()))
1131 }
1132}
1133
1134#[inline]
1138#[target_feature(enable = "avx512f,avx512vl")]
1139#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1140#[cfg_attr(test, assert_instr(vpsubd))]
1141#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1142pub const fn _mm256_maskz_sub_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1143 unsafe {
1144 let sub = _mm256_sub_epi32(a, b).as_i32x8();
1145 transmute(simd_select_bitmask(k, sub, i32x8::ZERO))
1146 }
1147}
1148
1149#[inline]
1153#[target_feature(enable = "avx512f,avx512vl")]
1154#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1155#[cfg_attr(test, assert_instr(vpsubd))]
1156#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1157pub const fn _mm_mask_sub_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1158 unsafe {
1159 let sub = _mm_sub_epi32(a, b).as_i32x4();
1160 transmute(simd_select_bitmask(k, sub, src.as_i32x4()))
1161 }
1162}
1163
1164#[inline]
1168#[target_feature(enable = "avx512f,avx512vl")]
1169#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1170#[cfg_attr(test, assert_instr(vpsubd))]
1171#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1172pub const fn _mm_maskz_sub_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1173 unsafe {
1174 let sub = _mm_sub_epi32(a, b).as_i32x4();
1175 transmute(simd_select_bitmask(k, sub, i32x4::ZERO))
1176 }
1177}
1178
1179#[inline]
1183#[target_feature(enable = "avx512f")]
1184#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1185#[cfg_attr(test, assert_instr(vpsubq))]
1186#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1187pub const fn _mm512_sub_epi64(a: __m512i, b: __m512i) -> __m512i {
1188 unsafe { transmute(simd_sub(a.as_i64x8(), b.as_i64x8())) }
1189}
1190
1191#[inline]
1195#[target_feature(enable = "avx512f")]
1196#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1197#[cfg_attr(test, assert_instr(vpsubq))]
1198#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1199pub const fn _mm512_mask_sub_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
1200 unsafe {
1201 let sub = _mm512_sub_epi64(a, b).as_i64x8();
1202 transmute(simd_select_bitmask(k, sub, src.as_i64x8()))
1203 }
1204}
1205
1206#[inline]
1210#[target_feature(enable = "avx512f")]
1211#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1212#[cfg_attr(test, assert_instr(vpsubq))]
1213#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1214pub const fn _mm512_maskz_sub_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
1215 unsafe {
1216 let sub = _mm512_sub_epi64(a, b).as_i64x8();
1217 transmute(simd_select_bitmask(k, sub, i64x8::ZERO))
1218 }
1219}
1220
1221#[inline]
1225#[target_feature(enable = "avx512f,avx512vl")]
1226#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1227#[cfg_attr(test, assert_instr(vpsubq))]
1228#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1229pub const fn _mm256_mask_sub_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1230 unsafe {
1231 let sub = _mm256_sub_epi64(a, b).as_i64x4();
1232 transmute(simd_select_bitmask(k, sub, src.as_i64x4()))
1233 }
1234}
1235
1236#[inline]
1240#[target_feature(enable = "avx512f,avx512vl")]
1241#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1242#[cfg_attr(test, assert_instr(vpsubq))]
1243#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1244pub const fn _mm256_maskz_sub_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1245 unsafe {
1246 let sub = _mm256_sub_epi64(a, b).as_i64x4();
1247 transmute(simd_select_bitmask(k, sub, i64x4::ZERO))
1248 }
1249}
1250
1251#[inline]
1255#[target_feature(enable = "avx512f,avx512vl")]
1256#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1257#[cfg_attr(test, assert_instr(vpsubq))]
1258#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1259pub const fn _mm_mask_sub_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1260 unsafe {
1261 let sub = _mm_sub_epi64(a, b).as_i64x2();
1262 transmute(simd_select_bitmask(k, sub, src.as_i64x2()))
1263 }
1264}
1265
1266#[inline]
1270#[target_feature(enable = "avx512f,avx512vl")]
1271#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1272#[cfg_attr(test, assert_instr(vpsubq))]
1273#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1274pub const fn _mm_maskz_sub_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1275 unsafe {
1276 let sub = _mm_sub_epi64(a, b).as_i64x2();
1277 transmute(simd_select_bitmask(k, sub, i64x2::ZERO))
1278 }
1279}
1280
1281#[inline]
1285#[target_feature(enable = "avx512f")]
1286#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1287#[cfg_attr(test, assert_instr(vsubps))]
1288#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1289pub const fn _mm512_sub_ps(a: __m512, b: __m512) -> __m512 {
1290 unsafe { transmute(simd_sub(a.as_f32x16(), b.as_f32x16())) }
1291}
1292
1293#[inline]
1297#[target_feature(enable = "avx512f")]
1298#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1299#[cfg_attr(test, assert_instr(vsubps))]
1300#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1301pub const fn _mm512_mask_sub_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
1302 unsafe {
1303 let sub = _mm512_sub_ps(a, b).as_f32x16();
1304 transmute(simd_select_bitmask(k, sub, src.as_f32x16()))
1305 }
1306}
1307
1308#[inline]
1312#[target_feature(enable = "avx512f")]
1313#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1314#[cfg_attr(test, assert_instr(vsubps))]
1315#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1316pub const fn _mm512_maskz_sub_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
1317 unsafe {
1318 let sub = _mm512_sub_ps(a, b).as_f32x16();
1319 transmute(simd_select_bitmask(k, sub, f32x16::ZERO))
1320 }
1321}
1322
1323#[inline]
1327#[target_feature(enable = "avx512f,avx512vl")]
1328#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1329#[cfg_attr(test, assert_instr(vsubps))]
1330#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1331pub const fn _mm256_mask_sub_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
1332 unsafe {
1333 let sub = _mm256_sub_ps(a, b).as_f32x8();
1334 transmute(simd_select_bitmask(k, sub, src.as_f32x8()))
1335 }
1336}
1337
1338#[inline]
1342#[target_feature(enable = "avx512f,avx512vl")]
1343#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1344#[cfg_attr(test, assert_instr(vsubps))]
1345#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1346pub const fn _mm256_maskz_sub_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
1347 unsafe {
1348 let sub = _mm256_sub_ps(a, b).as_f32x8();
1349 transmute(simd_select_bitmask(k, sub, f32x8::ZERO))
1350 }
1351}
1352
1353#[inline]
1357#[target_feature(enable = "avx512f,avx512vl")]
1358#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1359#[cfg_attr(test, assert_instr(vsubps))]
1360#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1361pub const fn _mm_mask_sub_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
1362 unsafe {
1363 let sub = _mm_sub_ps(a, b).as_f32x4();
1364 transmute(simd_select_bitmask(k, sub, src.as_f32x4()))
1365 }
1366}
1367
1368#[inline]
1372#[target_feature(enable = "avx512f,avx512vl")]
1373#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1374#[cfg_attr(test, assert_instr(vsubps))]
1375#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1376pub const fn _mm_maskz_sub_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
1377 unsafe {
1378 let sub = _mm_sub_ps(a, b).as_f32x4();
1379 transmute(simd_select_bitmask(k, sub, f32x4::ZERO))
1380 }
1381}
1382
1383#[inline]
1387#[target_feature(enable = "avx512f")]
1388#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1389#[cfg_attr(test, assert_instr(vsubpd))]
1390#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1391pub const fn _mm512_sub_pd(a: __m512d, b: __m512d) -> __m512d {
1392 unsafe { transmute(simd_sub(a.as_f64x8(), b.as_f64x8())) }
1393}
1394
1395#[inline]
1399#[target_feature(enable = "avx512f")]
1400#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1401#[cfg_attr(test, assert_instr(vsubpd))]
1402#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1403pub const fn _mm512_mask_sub_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
1404 unsafe {
1405 let sub = _mm512_sub_pd(a, b).as_f64x8();
1406 transmute(simd_select_bitmask(k, sub, src.as_f64x8()))
1407 }
1408}
1409
1410#[inline]
1414#[target_feature(enable = "avx512f")]
1415#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1416#[cfg_attr(test, assert_instr(vsubpd))]
1417#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1418pub const fn _mm512_maskz_sub_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
1419 unsafe {
1420 let sub = _mm512_sub_pd(a, b).as_f64x8();
1421 transmute(simd_select_bitmask(k, sub, f64x8::ZERO))
1422 }
1423}
1424
1425#[inline]
1429#[target_feature(enable = "avx512f,avx512vl")]
1430#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1431#[cfg_attr(test, assert_instr(vsubpd))]
1432#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1433pub const fn _mm256_mask_sub_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
1434 unsafe {
1435 let sub = _mm256_sub_pd(a, b).as_f64x4();
1436 transmute(simd_select_bitmask(k, sub, src.as_f64x4()))
1437 }
1438}
1439
1440#[inline]
1444#[target_feature(enable = "avx512f,avx512vl")]
1445#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1446#[cfg_attr(test, assert_instr(vsubpd))]
1447#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1448pub const fn _mm256_maskz_sub_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
1449 unsafe {
1450 let sub = _mm256_sub_pd(a, b).as_f64x4();
1451 transmute(simd_select_bitmask(k, sub, f64x4::ZERO))
1452 }
1453}
1454
1455#[inline]
1459#[target_feature(enable = "avx512f,avx512vl")]
1460#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1461#[cfg_attr(test, assert_instr(vsubpd))]
1462#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1463pub const fn _mm_mask_sub_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
1464 unsafe {
1465 let sub = _mm_sub_pd(a, b).as_f64x2();
1466 transmute(simd_select_bitmask(k, sub, src.as_f64x2()))
1467 }
1468}
1469
1470#[inline]
1474#[target_feature(enable = "avx512f,avx512vl")]
1475#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1476#[cfg_attr(test, assert_instr(vsubpd))]
1477#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1478pub const fn _mm_maskz_sub_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
1479 unsafe {
1480 let sub = _mm_sub_pd(a, b).as_f64x2();
1481 transmute(simd_select_bitmask(k, sub, f64x2::ZERO))
1482 }
1483}
1484
1485#[inline]
1489#[target_feature(enable = "avx512f")]
1490#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1491#[cfg_attr(test, assert_instr(vpmuldq))]
1492#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1493pub const fn _mm512_mul_epi32(a: __m512i, b: __m512i) -> __m512i {
1494 unsafe {
1495 let a = simd_cast::<_, i64x8>(simd_cast::<_, i32x8>(a.as_i64x8()));
1496 let b = simd_cast::<_, i64x8>(simd_cast::<_, i32x8>(b.as_i64x8()));
1497 transmute(simd_mul(a, b))
1498 }
1499}
1500
1501#[inline]
1505#[target_feature(enable = "avx512f")]
1506#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1507#[cfg_attr(test, assert_instr(vpmuldq))]
1508#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1509pub const fn _mm512_mask_mul_epi32(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
1510 unsafe {
1511 let mul = _mm512_mul_epi32(a, b).as_i64x8();
1512 transmute(simd_select_bitmask(k, mul, src.as_i64x8()))
1513 }
1514}
1515
1516#[inline]
1520#[target_feature(enable = "avx512f")]
1521#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1522#[cfg_attr(test, assert_instr(vpmuldq))]
1523#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1524pub const fn _mm512_maskz_mul_epi32(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
1525 unsafe {
1526 let mul = _mm512_mul_epi32(a, b).as_i64x8();
1527 transmute(simd_select_bitmask(k, mul, i64x8::ZERO))
1528 }
1529}
1530
1531#[inline]
1535#[target_feature(enable = "avx512f,avx512vl")]
1536#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1537#[cfg_attr(test, assert_instr(vpmuldq))]
1538#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1539pub const fn _mm256_mask_mul_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1540 unsafe {
1541 let mul = _mm256_mul_epi32(a, b).as_i64x4();
1542 transmute(simd_select_bitmask(k, mul, src.as_i64x4()))
1543 }
1544}
1545
1546#[inline]
1550#[target_feature(enable = "avx512f,avx512vl")]
1551#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1552#[cfg_attr(test, assert_instr(vpmuldq))]
1553#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1554pub const fn _mm256_maskz_mul_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1555 unsafe {
1556 let mul = _mm256_mul_epi32(a, b).as_i64x4();
1557 transmute(simd_select_bitmask(k, mul, i64x4::ZERO))
1558 }
1559}
1560
1561#[inline]
1565#[target_feature(enable = "avx512f,avx512vl")]
1566#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1567#[cfg_attr(test, assert_instr(vpmuldq))]
1568#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1569pub const fn _mm_mask_mul_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1570 unsafe {
1571 let mul = _mm_mul_epi32(a, b).as_i64x2();
1572 transmute(simd_select_bitmask(k, mul, src.as_i64x2()))
1573 }
1574}
1575
1576#[inline]
1580#[target_feature(enable = "avx512f,avx512vl")]
1581#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1582#[cfg_attr(test, assert_instr(vpmuldq))]
1583#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1584pub const fn _mm_maskz_mul_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1585 unsafe {
1586 let mul = _mm_mul_epi32(a, b).as_i64x2();
1587 transmute(simd_select_bitmask(k, mul, i64x2::ZERO))
1588 }
1589}
1590
1591#[inline]
1595#[target_feature(enable = "avx512f")]
1596#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1597#[cfg_attr(test, assert_instr(vpmulld))]
1598#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1599pub const fn _mm512_mullo_epi32(a: __m512i, b: __m512i) -> __m512i {
1600 unsafe { transmute(simd_mul(a.as_i32x16(), b.as_i32x16())) }
1601}
1602
1603#[inline]
1607#[target_feature(enable = "avx512f")]
1608#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1609#[cfg_attr(test, assert_instr(vpmulld))]
1610#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1611pub const fn _mm512_mask_mullo_epi32(
1612 src: __m512i,
1613 k: __mmask16,
1614 a: __m512i,
1615 b: __m512i,
1616) -> __m512i {
1617 unsafe {
1618 let mul = _mm512_mullo_epi32(a, b).as_i32x16();
1619 transmute(simd_select_bitmask(k, mul, src.as_i32x16()))
1620 }
1621}
1622
1623#[inline]
1627#[target_feature(enable = "avx512f")]
1628#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1629#[cfg_attr(test, assert_instr(vpmulld))]
1630#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1631pub const fn _mm512_maskz_mullo_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
1632 unsafe {
1633 let mul = _mm512_mullo_epi32(a, b).as_i32x16();
1634 transmute(simd_select_bitmask(k, mul, i32x16::ZERO))
1635 }
1636}
1637
1638#[inline]
1642#[target_feature(enable = "avx512f,avx512vl")]
1643#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1644#[cfg_attr(test, assert_instr(vpmulld))]
1645#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1646pub const fn _mm256_mask_mullo_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1647 unsafe {
1648 let mul = _mm256_mullo_epi32(a, b).as_i32x8();
1649 transmute(simd_select_bitmask(k, mul, src.as_i32x8()))
1650 }
1651}
1652
1653#[inline]
1657#[target_feature(enable = "avx512f,avx512vl")]
1658#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1659#[cfg_attr(test, assert_instr(vpmulld))]
1660#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1661pub const fn _mm256_maskz_mullo_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1662 unsafe {
1663 let mul = _mm256_mullo_epi32(a, b).as_i32x8();
1664 transmute(simd_select_bitmask(k, mul, i32x8::ZERO))
1665 }
1666}
1667
1668#[inline]
1672#[target_feature(enable = "avx512f,avx512vl")]
1673#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1674#[cfg_attr(test, assert_instr(vpmulld))]
1675#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1676pub const fn _mm_mask_mullo_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1677 unsafe {
1678 let mul = _mm_mullo_epi32(a, b).as_i32x4();
1679 transmute(simd_select_bitmask(k, mul, src.as_i32x4()))
1680 }
1681}
1682
1683#[inline]
1687#[target_feature(enable = "avx512f,avx512vl")]
1688#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1689#[cfg_attr(test, assert_instr(vpmulld))]
1690#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1691pub const fn _mm_maskz_mullo_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1692 unsafe {
1693 let mul = _mm_mullo_epi32(a, b).as_i32x4();
1694 transmute(simd_select_bitmask(k, mul, i32x4::ZERO))
1695 }
1696}
1697
1698#[inline]
1704#[target_feature(enable = "avx512f")]
1705#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1706#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1707pub const fn _mm512_mullox_epi64(a: __m512i, b: __m512i) -> __m512i {
1708 unsafe { transmute(simd_mul(a.as_i64x8(), b.as_i64x8())) }
1709}
1710
1711#[inline]
1717#[target_feature(enable = "avx512f")]
1718#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1719#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1720pub const fn _mm512_mask_mullox_epi64(
1721 src: __m512i,
1722 k: __mmask8,
1723 a: __m512i,
1724 b: __m512i,
1725) -> __m512i {
1726 unsafe {
1727 let mul = _mm512_mullox_epi64(a, b).as_i64x8();
1728 transmute(simd_select_bitmask(k, mul, src.as_i64x8()))
1729 }
1730}
1731
1732#[inline]
1736#[target_feature(enable = "avx512f")]
1737#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1738#[cfg_attr(test, assert_instr(vpmuludq))]
1739#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1740pub const fn _mm512_mul_epu32(a: __m512i, b: __m512i) -> __m512i {
1741 unsafe {
1742 let a = a.as_u64x8();
1743 let b = b.as_u64x8();
1744 let mask = u64x8::splat(u32::MAX as u64);
1745 transmute(simd_mul(simd_and(a, mask), simd_and(b, mask)))
1746 }
1747}
1748
1749#[inline]
1753#[target_feature(enable = "avx512f")]
1754#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1755#[cfg_attr(test, assert_instr(vpmuludq))]
1756#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1757pub const fn _mm512_mask_mul_epu32(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
1758 unsafe {
1759 let mul = _mm512_mul_epu32(a, b).as_u64x8();
1760 transmute(simd_select_bitmask(k, mul, src.as_u64x8()))
1761 }
1762}
1763
1764#[inline]
1768#[target_feature(enable = "avx512f")]
1769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1770#[cfg_attr(test, assert_instr(vpmuludq))]
1771#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1772pub const fn _mm512_maskz_mul_epu32(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
1773 unsafe {
1774 let mul = _mm512_mul_epu32(a, b).as_u64x8();
1775 transmute(simd_select_bitmask(k, mul, u64x8::ZERO))
1776 }
1777}
1778
1779#[inline]
1783#[target_feature(enable = "avx512f,avx512vl")]
1784#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1785#[cfg_attr(test, assert_instr(vpmuludq))]
1786#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1787pub const fn _mm256_mask_mul_epu32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1788 unsafe {
1789 let mul = _mm256_mul_epu32(a, b).as_u64x4();
1790 transmute(simd_select_bitmask(k, mul, src.as_u64x4()))
1791 }
1792}
1793
1794#[inline]
1798#[target_feature(enable = "avx512f,avx512vl")]
1799#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1800#[cfg_attr(test, assert_instr(vpmuludq))]
1801#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1802pub const fn _mm256_maskz_mul_epu32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
1803 unsafe {
1804 let mul = _mm256_mul_epu32(a, b).as_u64x4();
1805 transmute(simd_select_bitmask(k, mul, u64x4::ZERO))
1806 }
1807}
1808
1809#[inline]
1813#[target_feature(enable = "avx512f,avx512vl")]
1814#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1815#[cfg_attr(test, assert_instr(vpmuludq))]
1816#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1817pub const fn _mm_mask_mul_epu32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1818 unsafe {
1819 let mul = _mm_mul_epu32(a, b).as_u64x2();
1820 transmute(simd_select_bitmask(k, mul, src.as_u64x2()))
1821 }
1822}
1823
1824#[inline]
1828#[target_feature(enable = "avx512f,avx512vl")]
1829#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1830#[cfg_attr(test, assert_instr(vpmuludq))]
1831#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1832pub const fn _mm_maskz_mul_epu32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
1833 unsafe {
1834 let mul = _mm_mul_epu32(a, b).as_u64x2();
1835 transmute(simd_select_bitmask(k, mul, u64x2::ZERO))
1836 }
1837}
1838
1839#[inline]
1843#[target_feature(enable = "avx512f")]
1844#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1845#[cfg_attr(test, assert_instr(vmulps))]
1846#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1847pub const fn _mm512_mul_ps(a: __m512, b: __m512) -> __m512 {
1848 unsafe { transmute(simd_mul(a.as_f32x16(), b.as_f32x16())) }
1849}
1850
1851#[inline]
1855#[target_feature(enable = "avx512f")]
1856#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1857#[cfg_attr(test, assert_instr(vmulps))]
1858#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1859pub const fn _mm512_mask_mul_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
1860 unsafe {
1861 let mul = _mm512_mul_ps(a, b).as_f32x16();
1862 transmute(simd_select_bitmask(k, mul, src.as_f32x16()))
1863 }
1864}
1865
1866#[inline]
1870#[target_feature(enable = "avx512f")]
1871#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1872#[cfg_attr(test, assert_instr(vmulps))]
1873#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1874pub const fn _mm512_maskz_mul_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
1875 unsafe {
1876 let mul = _mm512_mul_ps(a, b).as_f32x16();
1877 transmute(simd_select_bitmask(k, mul, f32x16::ZERO))
1878 }
1879}
1880
1881#[inline]
1885#[target_feature(enable = "avx512f,avx512vl")]
1886#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1887#[cfg_attr(test, assert_instr(vmulps))]
1888#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1889pub const fn _mm256_mask_mul_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
1890 unsafe {
1891 let mul = _mm256_mul_ps(a, b).as_f32x8();
1892 transmute(simd_select_bitmask(k, mul, src.as_f32x8()))
1893 }
1894}
1895
1896#[inline]
1900#[target_feature(enable = "avx512f,avx512vl")]
1901#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1902#[cfg_attr(test, assert_instr(vmulps))]
1903#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1904pub const fn _mm256_maskz_mul_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
1905 unsafe {
1906 let mul = _mm256_mul_ps(a, b).as_f32x8();
1907 transmute(simd_select_bitmask(k, mul, f32x8::ZERO))
1908 }
1909}
1910
1911#[inline]
1915#[target_feature(enable = "avx512f,avx512vl")]
1916#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1917#[cfg_attr(test, assert_instr(vmulps))]
1918#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1919pub const fn _mm_mask_mul_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
1920 unsafe {
1921 let mul = _mm_mul_ps(a, b).as_f32x4();
1922 transmute(simd_select_bitmask(k, mul, src.as_f32x4()))
1923 }
1924}
1925
1926#[inline]
1930#[target_feature(enable = "avx512f,avx512vl")]
1931#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1932#[cfg_attr(test, assert_instr(vmulps))]
1933#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1934pub const fn _mm_maskz_mul_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
1935 unsafe {
1936 let mul = _mm_mul_ps(a, b).as_f32x4();
1937 transmute(simd_select_bitmask(k, mul, f32x4::ZERO))
1938 }
1939}
1940
1941#[inline]
1945#[target_feature(enable = "avx512f")]
1946#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1947#[cfg_attr(test, assert_instr(vmulpd))]
1948#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1949pub const fn _mm512_mul_pd(a: __m512d, b: __m512d) -> __m512d {
1950 unsafe { transmute(simd_mul(a.as_f64x8(), b.as_f64x8())) }
1951}
1952
1953#[inline]
1957#[target_feature(enable = "avx512f")]
1958#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1959#[cfg_attr(test, assert_instr(vmulpd))]
1960#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1961pub const fn _mm512_mask_mul_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
1962 unsafe {
1963 let mul = _mm512_mul_pd(a, b).as_f64x8();
1964 transmute(simd_select_bitmask(k, mul, src.as_f64x8()))
1965 }
1966}
1967
1968#[inline]
1972#[target_feature(enable = "avx512f")]
1973#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1974#[cfg_attr(test, assert_instr(vmulpd))]
1975#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1976pub const fn _mm512_maskz_mul_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
1977 unsafe {
1978 let mul = _mm512_mul_pd(a, b).as_f64x8();
1979 transmute(simd_select_bitmask(k, mul, f64x8::ZERO))
1980 }
1981}
1982
1983#[inline]
1987#[target_feature(enable = "avx512f,avx512vl")]
1988#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
1989#[cfg_attr(test, assert_instr(vmulpd))]
1990#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
1991pub const fn _mm256_mask_mul_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
1992 unsafe {
1993 let mul = _mm256_mul_pd(a, b).as_f64x4();
1994 transmute(simd_select_bitmask(k, mul, src.as_f64x4()))
1995 }
1996}
1997
1998#[inline]
2002#[target_feature(enable = "avx512f,avx512vl")]
2003#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2004#[cfg_attr(test, assert_instr(vmulpd))]
2005#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2006pub const fn _mm256_maskz_mul_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
2007 unsafe {
2008 let mul = _mm256_mul_pd(a, b).as_f64x4();
2009 transmute(simd_select_bitmask(k, mul, f64x4::ZERO))
2010 }
2011}
2012
2013#[inline]
2017#[target_feature(enable = "avx512f,avx512vl")]
2018#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2019#[cfg_attr(test, assert_instr(vmulpd))]
2020#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2021pub const fn _mm_mask_mul_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
2022 unsafe {
2023 let mul = _mm_mul_pd(a, b).as_f64x2();
2024 transmute(simd_select_bitmask(k, mul, src.as_f64x2()))
2025 }
2026}
2027
2028#[inline]
2032#[target_feature(enable = "avx512f,avx512vl")]
2033#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2034#[cfg_attr(test, assert_instr(vmulpd))]
2035#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2036pub const fn _mm_maskz_mul_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
2037 unsafe {
2038 let mul = _mm_mul_pd(a, b).as_f64x2();
2039 transmute(simd_select_bitmask(k, mul, f64x2::ZERO))
2040 }
2041}
2042
2043#[inline]
2047#[target_feature(enable = "avx512f")]
2048#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2049#[cfg_attr(test, assert_instr(vdivps))]
2050#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2051pub const fn _mm512_div_ps(a: __m512, b: __m512) -> __m512 {
2052 unsafe { transmute(simd_div(a.as_f32x16(), b.as_f32x16())) }
2053}
2054
2055#[inline]
2059#[target_feature(enable = "avx512f")]
2060#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2061#[cfg_attr(test, assert_instr(vdivps))]
2062#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2063pub const fn _mm512_mask_div_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
2064 unsafe {
2065 let div = _mm512_div_ps(a, b).as_f32x16();
2066 transmute(simd_select_bitmask(k, div, src.as_f32x16()))
2067 }
2068}
2069
2070#[inline]
2074#[target_feature(enable = "avx512f")]
2075#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2076#[cfg_attr(test, assert_instr(vdivps))]
2077#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2078pub const fn _mm512_maskz_div_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
2079 unsafe {
2080 let div = _mm512_div_ps(a, b).as_f32x16();
2081 transmute(simd_select_bitmask(k, div, f32x16::ZERO))
2082 }
2083}
2084
2085#[inline]
2089#[target_feature(enable = "avx512f,avx512vl")]
2090#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2091#[cfg_attr(test, assert_instr(vdivps))]
2092#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2093pub const fn _mm256_mask_div_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
2094 unsafe {
2095 let div = _mm256_div_ps(a, b).as_f32x8();
2096 transmute(simd_select_bitmask(k, div, src.as_f32x8()))
2097 }
2098}
2099
2100#[inline]
2104#[target_feature(enable = "avx512f,avx512vl")]
2105#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2106#[cfg_attr(test, assert_instr(vdivps))]
2107#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2108pub const fn _mm256_maskz_div_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
2109 unsafe {
2110 let div = _mm256_div_ps(a, b).as_f32x8();
2111 transmute(simd_select_bitmask(k, div, f32x8::ZERO))
2112 }
2113}
2114
2115#[inline]
2119#[target_feature(enable = "avx512f,avx512vl")]
2120#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2121#[cfg_attr(test, assert_instr(vdivps))]
2122#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2123pub const fn _mm_mask_div_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
2124 unsafe {
2125 let div = _mm_div_ps(a, b).as_f32x4();
2126 transmute(simd_select_bitmask(k, div, src.as_f32x4()))
2127 }
2128}
2129
2130#[inline]
2134#[target_feature(enable = "avx512f,avx512vl")]
2135#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2136#[cfg_attr(test, assert_instr(vdivps))]
2137#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2138pub const fn _mm_maskz_div_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
2139 unsafe {
2140 let div = _mm_div_ps(a, b).as_f32x4();
2141 transmute(simd_select_bitmask(k, div, f32x4::ZERO))
2142 }
2143}
2144
2145#[inline]
2149#[target_feature(enable = "avx512f")]
2150#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2151#[cfg_attr(test, assert_instr(vdivpd))]
2152#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2153pub const fn _mm512_div_pd(a: __m512d, b: __m512d) -> __m512d {
2154 unsafe { transmute(simd_div(a.as_f64x8(), b.as_f64x8())) }
2155}
2156
2157#[inline]
2161#[target_feature(enable = "avx512f")]
2162#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2163#[cfg_attr(test, assert_instr(vdivpd))]
2164#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2165pub const fn _mm512_mask_div_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
2166 unsafe {
2167 let div = _mm512_div_pd(a, b).as_f64x8();
2168 transmute(simd_select_bitmask(k, div, src.as_f64x8()))
2169 }
2170}
2171
2172#[inline]
2176#[target_feature(enable = "avx512f")]
2177#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2178#[cfg_attr(test, assert_instr(vdivpd))]
2179#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2180pub const fn _mm512_maskz_div_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
2181 unsafe {
2182 let div = _mm512_div_pd(a, b).as_f64x8();
2183 transmute(simd_select_bitmask(k, div, f64x8::ZERO))
2184 }
2185}
2186
2187#[inline]
2191#[target_feature(enable = "avx512f,avx512vl")]
2192#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2193#[cfg_attr(test, assert_instr(vdivpd))]
2194#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2195pub const fn _mm256_mask_div_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
2196 unsafe {
2197 let div = _mm256_div_pd(a, b).as_f64x4();
2198 transmute(simd_select_bitmask(k, div, src.as_f64x4()))
2199 }
2200}
2201
2202#[inline]
2206#[target_feature(enable = "avx512f,avx512vl")]
2207#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2208#[cfg_attr(test, assert_instr(vdivpd))]
2209#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2210pub const fn _mm256_maskz_div_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
2211 unsafe {
2212 let div = _mm256_div_pd(a, b).as_f64x4();
2213 transmute(simd_select_bitmask(k, div, f64x4::ZERO))
2214 }
2215}
2216
2217#[inline]
2221#[target_feature(enable = "avx512f,avx512vl")]
2222#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2223#[cfg_attr(test, assert_instr(vdivpd))]
2224#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2225pub const fn _mm_mask_div_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
2226 unsafe {
2227 let div = _mm_div_pd(a, b).as_f64x2();
2228 transmute(simd_select_bitmask(k, div, src.as_f64x2()))
2229 }
2230}
2231
2232#[inline]
2236#[target_feature(enable = "avx512f,avx512vl")]
2237#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2238#[cfg_attr(test, assert_instr(vdivpd))]
2239#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2240pub const fn _mm_maskz_div_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
2241 unsafe {
2242 let div = _mm_div_pd(a, b).as_f64x2();
2243 transmute(simd_select_bitmask(k, div, f64x2::ZERO))
2244 }
2245}
2246
2247#[inline]
2251#[target_feature(enable = "avx512f")]
2252#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2253#[cfg_attr(test, assert_instr(vpmaxsd))]
2254#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2255pub const fn _mm512_max_epi32(a: __m512i, b: __m512i) -> __m512i {
2256 unsafe { simd_imax(a.as_i32x16(), b.as_i32x16()).as_m512i() }
2257}
2258
2259#[inline]
2263#[target_feature(enable = "avx512f")]
2264#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2265#[cfg_attr(test, assert_instr(vpmaxsd))]
2266#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2267pub const fn _mm512_mask_max_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
2268 unsafe {
2269 let max = _mm512_max_epi32(a, b).as_i32x16();
2270 transmute(simd_select_bitmask(k, max, src.as_i32x16()))
2271 }
2272}
2273
2274#[inline]
2278#[target_feature(enable = "avx512f")]
2279#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2280#[cfg_attr(test, assert_instr(vpmaxsd))]
2281#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2282pub const fn _mm512_maskz_max_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
2283 unsafe {
2284 let max = _mm512_max_epi32(a, b).as_i32x16();
2285 transmute(simd_select_bitmask(k, max, i32x16::ZERO))
2286 }
2287}
2288
2289#[inline]
2293#[target_feature(enable = "avx512f,avx512vl")]
2294#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2295#[cfg_attr(test, assert_instr(vpmaxsd))]
2296#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2297pub const fn _mm256_mask_max_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2298 unsafe {
2299 let max = _mm256_max_epi32(a, b).as_i32x8();
2300 transmute(simd_select_bitmask(k, max, src.as_i32x8()))
2301 }
2302}
2303
2304#[inline]
2308#[target_feature(enable = "avx512f,avx512vl")]
2309#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2310#[cfg_attr(test, assert_instr(vpmaxsd))]
2311#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2312pub const fn _mm256_maskz_max_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2313 unsafe {
2314 let max = _mm256_max_epi32(a, b).as_i32x8();
2315 transmute(simd_select_bitmask(k, max, i32x8::ZERO))
2316 }
2317}
2318
2319#[inline]
2323#[target_feature(enable = "avx512f,avx512vl")]
2324#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2325#[cfg_attr(test, assert_instr(vpmaxsd))]
2326#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2327pub const fn _mm_mask_max_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2328 unsafe {
2329 let max = _mm_max_epi32(a, b).as_i32x4();
2330 transmute(simd_select_bitmask(k, max, src.as_i32x4()))
2331 }
2332}
2333
2334#[inline]
2338#[target_feature(enable = "avx512f,avx512vl")]
2339#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2340#[cfg_attr(test, assert_instr(vpmaxsd))]
2341#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2342pub const fn _mm_maskz_max_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2343 unsafe {
2344 let max = _mm_max_epi32(a, b).as_i32x4();
2345 transmute(simd_select_bitmask(k, max, i32x4::ZERO))
2346 }
2347}
2348
2349#[inline]
2353#[target_feature(enable = "avx512f")]
2354#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2355#[cfg_attr(test, assert_instr(vpmaxsq))]
2356#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2357pub const fn _mm512_max_epi64(a: __m512i, b: __m512i) -> __m512i {
2358 unsafe { simd_imax(a.as_i64x8(), b.as_i64x8()).as_m512i() }
2359}
2360
2361#[inline]
2365#[target_feature(enable = "avx512f")]
2366#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2367#[cfg_attr(test, assert_instr(vpmaxsq))]
2368#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2369pub const fn _mm512_mask_max_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
2370 unsafe {
2371 let max = _mm512_max_epi64(a, b).as_i64x8();
2372 transmute(simd_select_bitmask(k, max, src.as_i64x8()))
2373 }
2374}
2375
2376#[inline]
2380#[target_feature(enable = "avx512f")]
2381#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2382#[cfg_attr(test, assert_instr(vpmaxsq))]
2383#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2384pub const fn _mm512_maskz_max_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
2385 unsafe {
2386 let max = _mm512_max_epi64(a, b).as_i64x8();
2387 transmute(simd_select_bitmask(k, max, i64x8::ZERO))
2388 }
2389}
2390
2391#[inline]
2395#[target_feature(enable = "avx512f,avx512vl")]
2396#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2397#[cfg_attr(test, assert_instr(vpmaxsq))]
2398#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2399pub const fn _mm256_max_epi64(a: __m256i, b: __m256i) -> __m256i {
2400 unsafe { simd_imax(a.as_i64x4(), b.as_i64x4()).as_m256i() }
2401}
2402
2403#[inline]
2407#[target_feature(enable = "avx512f,avx512vl")]
2408#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2409#[cfg_attr(test, assert_instr(vpmaxsq))]
2410#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2411pub const fn _mm256_mask_max_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2412 unsafe {
2413 let max = _mm256_max_epi64(a, b).as_i64x4();
2414 transmute(simd_select_bitmask(k, max, src.as_i64x4()))
2415 }
2416}
2417
2418#[inline]
2422#[target_feature(enable = "avx512f,avx512vl")]
2423#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2424#[cfg_attr(test, assert_instr(vpmaxsq))]
2425#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2426pub const fn _mm256_maskz_max_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2427 unsafe {
2428 let max = _mm256_max_epi64(a, b).as_i64x4();
2429 transmute(simd_select_bitmask(k, max, i64x4::ZERO))
2430 }
2431}
2432
2433#[inline]
2437#[target_feature(enable = "avx512f,avx512vl")]
2438#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2439#[cfg_attr(test, assert_instr(vpmaxsq))]
2440#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2441pub const fn _mm_max_epi64(a: __m128i, b: __m128i) -> __m128i {
2442 unsafe { simd_imax(a.as_i64x2(), b.as_i64x2()).as_m128i() }
2443}
2444
2445#[inline]
2449#[target_feature(enable = "avx512f,avx512vl")]
2450#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2451#[cfg_attr(test, assert_instr(vpmaxsq))]
2452#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2453pub const fn _mm_mask_max_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2454 unsafe {
2455 let max = _mm_max_epi64(a, b).as_i64x2();
2456 transmute(simd_select_bitmask(k, max, src.as_i64x2()))
2457 }
2458}
2459
2460#[inline]
2464#[target_feature(enable = "avx512f,avx512vl")]
2465#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2466#[cfg_attr(test, assert_instr(vpmaxsq))]
2467#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2468pub const fn _mm_maskz_max_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2469 unsafe {
2470 let max = _mm_max_epi64(a, b).as_i64x2();
2471 transmute(simd_select_bitmask(k, max, i64x2::ZERO))
2472 }
2473}
2474
2475#[inline]
2479#[target_feature(enable = "avx512f")]
2480#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2481#[cfg_attr(test, assert_instr(vmaxps))]
2482pub fn _mm512_max_ps(a: __m512, b: __m512) -> __m512 {
2483 unsafe {
2484 transmute(vmaxps(
2485 a.as_f32x16(),
2486 b.as_f32x16(),
2487 _MM_FROUND_CUR_DIRECTION,
2488 ))
2489 }
2490}
2491
2492#[inline]
2496#[target_feature(enable = "avx512f")]
2497#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2498#[cfg_attr(test, assert_instr(vmaxps))]
2499pub fn _mm512_mask_max_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
2500 unsafe {
2501 let max = _mm512_max_ps(a, b).as_f32x16();
2502 transmute(simd_select_bitmask(k, max, src.as_f32x16()))
2503 }
2504}
2505
2506#[inline]
2510#[target_feature(enable = "avx512f")]
2511#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2512#[cfg_attr(test, assert_instr(vmaxps))]
2513pub fn _mm512_maskz_max_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
2514 unsafe {
2515 let max = _mm512_max_ps(a, b).as_f32x16();
2516 transmute(simd_select_bitmask(k, max, f32x16::ZERO))
2517 }
2518}
2519
2520#[inline]
2524#[target_feature(enable = "avx512f,avx512vl")]
2525#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2526#[cfg_attr(test, assert_instr(vmaxps))]
2527pub fn _mm256_mask_max_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
2528 unsafe {
2529 let max = _mm256_max_ps(a, b).as_f32x8();
2530 transmute(simd_select_bitmask(k, max, src.as_f32x8()))
2531 }
2532}
2533
2534#[inline]
2538#[target_feature(enable = "avx512f,avx512vl")]
2539#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2540#[cfg_attr(test, assert_instr(vmaxps))]
2541pub fn _mm256_maskz_max_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
2542 unsafe {
2543 let max = _mm256_max_ps(a, b).as_f32x8();
2544 transmute(simd_select_bitmask(k, max, f32x8::ZERO))
2545 }
2546}
2547
2548#[inline]
2552#[target_feature(enable = "avx512f,avx512vl")]
2553#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2554#[cfg_attr(test, assert_instr(vmaxps))]
2555pub fn _mm_mask_max_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
2556 unsafe {
2557 let max = _mm_max_ps(a, b).as_f32x4();
2558 transmute(simd_select_bitmask(k, max, src.as_f32x4()))
2559 }
2560}
2561
2562#[inline]
2566#[target_feature(enable = "avx512f,avx512vl")]
2567#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2568#[cfg_attr(test, assert_instr(vmaxps))]
2569pub fn _mm_maskz_max_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
2570 unsafe {
2571 let max = _mm_max_ps(a, b).as_f32x4();
2572 transmute(simd_select_bitmask(k, max, f32x4::ZERO))
2573 }
2574}
2575
2576#[inline]
2580#[target_feature(enable = "avx512f")]
2581#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2582#[cfg_attr(test, assert_instr(vmaxpd))]
2583pub fn _mm512_max_pd(a: __m512d, b: __m512d) -> __m512d {
2584 unsafe { transmute(vmaxpd(a.as_f64x8(), b.as_f64x8(), _MM_FROUND_CUR_DIRECTION)) }
2585}
2586
2587#[inline]
2591#[target_feature(enable = "avx512f")]
2592#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2593#[cfg_attr(test, assert_instr(vmaxpd))]
2594pub fn _mm512_mask_max_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
2595 unsafe {
2596 let max = _mm512_max_pd(a, b).as_f64x8();
2597 transmute(simd_select_bitmask(k, max, src.as_f64x8()))
2598 }
2599}
2600
2601#[inline]
2605#[target_feature(enable = "avx512f")]
2606#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2607#[cfg_attr(test, assert_instr(vmaxpd))]
2608pub fn _mm512_maskz_max_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
2609 unsafe {
2610 let max = _mm512_max_pd(a, b).as_f64x8();
2611 transmute(simd_select_bitmask(k, max, f64x8::ZERO))
2612 }
2613}
2614
2615#[inline]
2619#[target_feature(enable = "avx512f,avx512vl")]
2620#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2621#[cfg_attr(test, assert_instr(vmaxpd))]
2622pub fn _mm256_mask_max_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
2623 unsafe {
2624 let max = _mm256_max_pd(a, b).as_f64x4();
2625 transmute(simd_select_bitmask(k, max, src.as_f64x4()))
2626 }
2627}
2628
2629#[inline]
2633#[target_feature(enable = "avx512f,avx512vl")]
2634#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2635#[cfg_attr(test, assert_instr(vmaxpd))]
2636pub fn _mm256_maskz_max_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
2637 unsafe {
2638 let max = _mm256_max_pd(a, b).as_f64x4();
2639 transmute(simd_select_bitmask(k, max, f64x4::ZERO))
2640 }
2641}
2642
2643#[inline]
2647#[target_feature(enable = "avx512f,avx512vl")]
2648#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2649#[cfg_attr(test, assert_instr(vmaxpd))]
2650pub fn _mm_mask_max_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
2651 unsafe {
2652 let max = _mm_max_pd(a, b).as_f64x2();
2653 transmute(simd_select_bitmask(k, max, src.as_f64x2()))
2654 }
2655}
2656
2657#[inline]
2661#[target_feature(enable = "avx512f,avx512vl")]
2662#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2663#[cfg_attr(test, assert_instr(vmaxpd))]
2664pub fn _mm_maskz_max_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
2665 unsafe {
2666 let max = _mm_max_pd(a, b).as_f64x2();
2667 transmute(simd_select_bitmask(k, max, f64x2::ZERO))
2668 }
2669}
2670
2671#[inline]
2675#[target_feature(enable = "avx512f")]
2676#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2677#[cfg_attr(test, assert_instr(vpmaxud))]
2678#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2679pub const fn _mm512_max_epu32(a: __m512i, b: __m512i) -> __m512i {
2680 unsafe { simd_imax(a.as_u32x16(), b.as_u32x16()).as_m512i() }
2681}
2682
2683#[inline]
2687#[target_feature(enable = "avx512f")]
2688#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2689#[cfg_attr(test, assert_instr(vpmaxud))]
2690#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2691pub const fn _mm512_mask_max_epu32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
2692 unsafe {
2693 let max = _mm512_max_epu32(a, b).as_u32x16();
2694 transmute(simd_select_bitmask(k, max, src.as_u32x16()))
2695 }
2696}
2697
2698#[inline]
2702#[target_feature(enable = "avx512f")]
2703#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2704#[cfg_attr(test, assert_instr(vpmaxud))]
2705#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2706pub const fn _mm512_maskz_max_epu32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
2707 unsafe {
2708 let max = _mm512_max_epu32(a, b).as_u32x16();
2709 transmute(simd_select_bitmask(k, max, u32x16::ZERO))
2710 }
2711}
2712
2713#[inline]
2717#[target_feature(enable = "avx512f,avx512vl")]
2718#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2719#[cfg_attr(test, assert_instr(vpmaxud))]
2720#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2721pub const fn _mm256_mask_max_epu32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2722 unsafe {
2723 let max = _mm256_max_epu32(a, b).as_u32x8();
2724 transmute(simd_select_bitmask(k, max, src.as_u32x8()))
2725 }
2726}
2727
2728#[inline]
2732#[target_feature(enable = "avx512f,avx512vl")]
2733#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2734#[cfg_attr(test, assert_instr(vpmaxud))]
2735#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2736pub const fn _mm256_maskz_max_epu32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2737 unsafe {
2738 let max = _mm256_max_epu32(a, b).as_u32x8();
2739 transmute(simd_select_bitmask(k, max, u32x8::ZERO))
2740 }
2741}
2742
2743#[inline]
2747#[target_feature(enable = "avx512f,avx512vl")]
2748#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2749#[cfg_attr(test, assert_instr(vpmaxud))]
2750#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2751pub const fn _mm_mask_max_epu32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2752 unsafe {
2753 let max = _mm_max_epu32(a, b).as_u32x4();
2754 transmute(simd_select_bitmask(k, max, src.as_u32x4()))
2755 }
2756}
2757
2758#[inline]
2762#[target_feature(enable = "avx512f,avx512vl")]
2763#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2764#[cfg_attr(test, assert_instr(vpmaxud))]
2765#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2766pub const fn _mm_maskz_max_epu32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2767 unsafe {
2768 let max = _mm_max_epu32(a, b).as_u32x4();
2769 transmute(simd_select_bitmask(k, max, u32x4::ZERO))
2770 }
2771}
2772
2773#[inline]
2777#[target_feature(enable = "avx512f")]
2778#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2779#[cfg_attr(test, assert_instr(vpmaxuq))]
2780#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2781pub const fn _mm512_max_epu64(a: __m512i, b: __m512i) -> __m512i {
2782 unsafe { simd_imax(a.as_u64x8(), b.as_u64x8()).as_m512i() }
2783}
2784
2785#[inline]
2789#[target_feature(enable = "avx512f")]
2790#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2791#[cfg_attr(test, assert_instr(vpmaxuq))]
2792#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2793pub const fn _mm512_mask_max_epu64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
2794 unsafe {
2795 let max = _mm512_max_epu64(a, b).as_u64x8();
2796 transmute(simd_select_bitmask(k, max, src.as_u64x8()))
2797 }
2798}
2799
2800#[inline]
2804#[target_feature(enable = "avx512f")]
2805#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2806#[cfg_attr(test, assert_instr(vpmaxuq))]
2807#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2808pub const fn _mm512_maskz_max_epu64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
2809 unsafe {
2810 let max = _mm512_max_epu64(a, b).as_u64x8();
2811 transmute(simd_select_bitmask(k, max, u64x8::ZERO))
2812 }
2813}
2814
2815#[inline]
2819#[target_feature(enable = "avx512f,avx512vl")]
2820#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2821#[cfg_attr(test, assert_instr(vpmaxuq))]
2822#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2823pub const fn _mm256_max_epu64(a: __m256i, b: __m256i) -> __m256i {
2824 unsafe { simd_imax(a.as_u64x4(), b.as_u64x4()).as_m256i() }
2825}
2826
2827#[inline]
2831#[target_feature(enable = "avx512f,avx512vl")]
2832#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2833#[cfg_attr(test, assert_instr(vpmaxuq))]
2834#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2835pub const fn _mm256_mask_max_epu64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2836 unsafe {
2837 let max = _mm256_max_epu64(a, b).as_u64x4();
2838 transmute(simd_select_bitmask(k, max, src.as_u64x4()))
2839 }
2840}
2841
2842#[inline]
2846#[target_feature(enable = "avx512f,avx512vl")]
2847#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2848#[cfg_attr(test, assert_instr(vpmaxuq))]
2849#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2850pub const fn _mm256_maskz_max_epu64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2851 unsafe {
2852 let max = _mm256_max_epu64(a, b).as_u64x4();
2853 transmute(simd_select_bitmask(k, max, u64x4::ZERO))
2854 }
2855}
2856
2857#[inline]
2861#[target_feature(enable = "avx512f,avx512vl")]
2862#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2863#[cfg_attr(test, assert_instr(vpmaxuq))]
2864#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2865pub const fn _mm_max_epu64(a: __m128i, b: __m128i) -> __m128i {
2866 unsafe { simd_imax(a.as_u64x2(), b.as_u64x2()).as_m128i() }
2867}
2868
2869#[inline]
2873#[target_feature(enable = "avx512f,avx512vl")]
2874#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2875#[cfg_attr(test, assert_instr(vpmaxuq))]
2876#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2877pub const fn _mm_mask_max_epu64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2878 unsafe {
2879 let max = _mm_max_epu64(a, b).as_u64x2();
2880 transmute(simd_select_bitmask(k, max, src.as_u64x2()))
2881 }
2882}
2883
2884#[inline]
2888#[target_feature(enable = "avx512f,avx512vl")]
2889#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2890#[cfg_attr(test, assert_instr(vpmaxuq))]
2891#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2892pub const fn _mm_maskz_max_epu64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2893 unsafe {
2894 let max = _mm_max_epu64(a, b).as_u64x2();
2895 transmute(simd_select_bitmask(k, max, u64x2::ZERO))
2896 }
2897}
2898
2899#[inline]
2903#[target_feature(enable = "avx512f")]
2904#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2905#[cfg_attr(test, assert_instr(vpminsd))]
2906#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2907pub const fn _mm512_min_epi32(a: __m512i, b: __m512i) -> __m512i {
2908 unsafe { simd_imin(a.as_i32x16(), b.as_i32x16()).as_m512i() }
2909}
2910
2911#[inline]
2915#[target_feature(enable = "avx512f")]
2916#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2917#[cfg_attr(test, assert_instr(vpminsd))]
2918#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2919pub const fn _mm512_mask_min_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
2920 unsafe {
2921 let min = _mm512_min_epi32(a, b).as_i32x16();
2922 transmute(simd_select_bitmask(k, min, src.as_i32x16()))
2923 }
2924}
2925
2926#[inline]
2930#[target_feature(enable = "avx512f")]
2931#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2932#[cfg_attr(test, assert_instr(vpminsd))]
2933#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2934pub const fn _mm512_maskz_min_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
2935 unsafe {
2936 let min = _mm512_min_epi32(a, b).as_i32x16();
2937 transmute(simd_select_bitmask(k, min, i32x16::ZERO))
2938 }
2939}
2940
2941#[inline]
2945#[target_feature(enable = "avx512f,avx512vl")]
2946#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2947#[cfg_attr(test, assert_instr(vpminsd))]
2948#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2949pub const fn _mm256_mask_min_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2950 unsafe {
2951 let min = _mm256_min_epi32(a, b).as_i32x8();
2952 transmute(simd_select_bitmask(k, min, src.as_i32x8()))
2953 }
2954}
2955
2956#[inline]
2960#[target_feature(enable = "avx512f,avx512vl")]
2961#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2962#[cfg_attr(test, assert_instr(vpminsd))]
2963#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2964pub const fn _mm256_maskz_min_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
2965 unsafe {
2966 let min = _mm256_min_epi32(a, b).as_i32x8();
2967 transmute(simd_select_bitmask(k, min, i32x8::ZERO))
2968 }
2969}
2970
2971#[inline]
2975#[target_feature(enable = "avx512f,avx512vl")]
2976#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2977#[cfg_attr(test, assert_instr(vpminsd))]
2978#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2979pub const fn _mm_mask_min_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2980 unsafe {
2981 let min = _mm_min_epi32(a, b).as_i32x4();
2982 transmute(simd_select_bitmask(k, min, src.as_i32x4()))
2983 }
2984}
2985
2986#[inline]
2990#[target_feature(enable = "avx512f,avx512vl")]
2991#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
2992#[cfg_attr(test, assert_instr(vpminsd))]
2993#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
2994pub const fn _mm_maskz_min_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
2995 unsafe {
2996 let min = _mm_min_epi32(a, b).as_i32x4();
2997 transmute(simd_select_bitmask(k, min, i32x4::ZERO))
2998 }
2999}
3000
3001#[inline]
3005#[target_feature(enable = "avx512f")]
3006#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3007#[cfg_attr(test, assert_instr(vpminsq))]
3008#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3009pub const fn _mm512_min_epi64(a: __m512i, b: __m512i) -> __m512i {
3010 unsafe { simd_imin(a.as_i64x8(), b.as_i64x8()).as_m512i() }
3011}
3012
3013#[inline]
3017#[target_feature(enable = "avx512f")]
3018#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3019#[cfg_attr(test, assert_instr(vpminsq))]
3020#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3021pub const fn _mm512_mask_min_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
3022 unsafe {
3023 let min = _mm512_min_epi64(a, b).as_i64x8();
3024 transmute(simd_select_bitmask(k, min, src.as_i64x8()))
3025 }
3026}
3027
3028#[inline]
3032#[target_feature(enable = "avx512f")]
3033#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3034#[cfg_attr(test, assert_instr(vpminsq))]
3035#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3036pub const fn _mm512_maskz_min_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
3037 unsafe {
3038 let min = _mm512_min_epi64(a, b).as_i64x8();
3039 transmute(simd_select_bitmask(k, min, i64x8::ZERO))
3040 }
3041}
3042
3043#[inline]
3047#[target_feature(enable = "avx512f,avx512vl")]
3048#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3049#[cfg_attr(test, assert_instr(vpminsq))]
3050#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3051pub const fn _mm256_min_epi64(a: __m256i, b: __m256i) -> __m256i {
3052 unsafe { simd_imin(a.as_i64x4(), b.as_i64x4()).as_m256i() }
3053}
3054
3055#[inline]
3059#[target_feature(enable = "avx512f,avx512vl")]
3060#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3061#[cfg_attr(test, assert_instr(vpminsq))]
3062#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3063pub const fn _mm256_mask_min_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
3064 unsafe {
3065 let min = _mm256_min_epi64(a, b).as_i64x4();
3066 transmute(simd_select_bitmask(k, min, src.as_i64x4()))
3067 }
3068}
3069
3070#[inline]
3074#[target_feature(enable = "avx512f,avx512vl")]
3075#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3076#[cfg_attr(test, assert_instr(vpminsq))]
3077#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3078pub const fn _mm256_maskz_min_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
3079 unsafe {
3080 let min = _mm256_min_epi64(a, b).as_i64x4();
3081 transmute(simd_select_bitmask(k, min, i64x4::ZERO))
3082 }
3083}
3084
3085#[inline]
3089#[target_feature(enable = "avx512f,avx512vl")]
3090#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3091#[cfg_attr(test, assert_instr(vpminsq))]
3092#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3093pub const fn _mm_min_epi64(a: __m128i, b: __m128i) -> __m128i {
3094 unsafe { simd_imin(a.as_i64x2(), b.as_i64x2()).as_m128i() }
3095}
3096
3097#[inline]
3101#[target_feature(enable = "avx512f,avx512vl")]
3102#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3103#[cfg_attr(test, assert_instr(vpminsq))]
3104#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3105pub const fn _mm_mask_min_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
3106 unsafe {
3107 let min = _mm_min_epi64(a, b).as_i64x2();
3108 transmute(simd_select_bitmask(k, min, src.as_i64x2()))
3109 }
3110}
3111
3112#[inline]
3116#[target_feature(enable = "avx512f,avx512vl")]
3117#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3118#[cfg_attr(test, assert_instr(vpminsq))]
3119#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3120pub const fn _mm_maskz_min_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
3121 unsafe {
3122 let min = _mm_min_epi64(a, b).as_i64x2();
3123 transmute(simd_select_bitmask(k, min, i64x2::ZERO))
3124 }
3125}
3126
3127#[inline]
3131#[target_feature(enable = "avx512f")]
3132#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3133#[cfg_attr(test, assert_instr(vminps))]
3134pub fn _mm512_min_ps(a: __m512, b: __m512) -> __m512 {
3135 unsafe {
3136 transmute(vminps(
3137 a.as_f32x16(),
3138 b.as_f32x16(),
3139 _MM_FROUND_CUR_DIRECTION,
3140 ))
3141 }
3142}
3143
3144#[inline]
3148#[target_feature(enable = "avx512f")]
3149#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3150#[cfg_attr(test, assert_instr(vminps))]
3151pub fn _mm512_mask_min_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
3152 unsafe {
3153 let min = _mm512_min_ps(a, b).as_f32x16();
3154 transmute(simd_select_bitmask(k, min, src.as_f32x16()))
3155 }
3156}
3157
3158#[inline]
3162#[target_feature(enable = "avx512f")]
3163#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3164#[cfg_attr(test, assert_instr(vminps))]
3165pub fn _mm512_maskz_min_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
3166 unsafe {
3167 let min = _mm512_min_ps(a, b).as_f32x16();
3168 transmute(simd_select_bitmask(k, min, f32x16::ZERO))
3169 }
3170}
3171
3172#[inline]
3176#[target_feature(enable = "avx512f,avx512vl")]
3177#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3178#[cfg_attr(test, assert_instr(vminps))]
3179pub fn _mm256_mask_min_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
3180 unsafe {
3181 let min = _mm256_min_ps(a, b).as_f32x8();
3182 transmute(simd_select_bitmask(k, min, src.as_f32x8()))
3183 }
3184}
3185
3186#[inline]
3190#[target_feature(enable = "avx512f,avx512vl")]
3191#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3192#[cfg_attr(test, assert_instr(vminps))]
3193pub fn _mm256_maskz_min_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
3194 unsafe {
3195 let min = _mm256_min_ps(a, b).as_f32x8();
3196 transmute(simd_select_bitmask(k, min, f32x8::ZERO))
3197 }
3198}
3199
3200#[inline]
3204#[target_feature(enable = "avx512f,avx512vl")]
3205#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3206#[cfg_attr(test, assert_instr(vminps))]
3207pub fn _mm_mask_min_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
3208 unsafe {
3209 let min = _mm_min_ps(a, b).as_f32x4();
3210 transmute(simd_select_bitmask(k, min, src.as_f32x4()))
3211 }
3212}
3213
3214#[inline]
3218#[target_feature(enable = "avx512f,avx512vl")]
3219#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3220#[cfg_attr(test, assert_instr(vminps))]
3221pub fn _mm_maskz_min_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
3222 unsafe {
3223 let min = _mm_min_ps(a, b).as_f32x4();
3224 transmute(simd_select_bitmask(k, min, f32x4::ZERO))
3225 }
3226}
3227
3228#[inline]
3232#[target_feature(enable = "avx512f")]
3233#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3234#[cfg_attr(test, assert_instr(vminpd))]
3235pub fn _mm512_min_pd(a: __m512d, b: __m512d) -> __m512d {
3236 unsafe { transmute(vminpd(a.as_f64x8(), b.as_f64x8(), _MM_FROUND_CUR_DIRECTION)) }
3237}
3238
3239#[inline]
3243#[target_feature(enable = "avx512f")]
3244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3245#[cfg_attr(test, assert_instr(vminpd))]
3246pub fn _mm512_mask_min_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
3247 unsafe {
3248 let min = _mm512_min_pd(a, b).as_f64x8();
3249 transmute(simd_select_bitmask(k, min, src.as_f64x8()))
3250 }
3251}
3252
3253#[inline]
3257#[target_feature(enable = "avx512f")]
3258#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3259#[cfg_attr(test, assert_instr(vminpd))]
3260pub fn _mm512_maskz_min_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
3261 unsafe {
3262 let min = _mm512_min_pd(a, b).as_f64x8();
3263 transmute(simd_select_bitmask(k, min, f64x8::ZERO))
3264 }
3265}
3266
3267#[inline]
3271#[target_feature(enable = "avx512f,avx512vl")]
3272#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3273#[cfg_attr(test, assert_instr(vminpd))]
3274pub fn _mm256_mask_min_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
3275 unsafe {
3276 let min = _mm256_min_pd(a, b).as_f64x4();
3277 transmute(simd_select_bitmask(k, min, src.as_f64x4()))
3278 }
3279}
3280
3281#[inline]
3285#[target_feature(enable = "avx512f,avx512vl")]
3286#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3287#[cfg_attr(test, assert_instr(vminpd))]
3288pub fn _mm256_maskz_min_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
3289 unsafe {
3290 let min = _mm256_min_pd(a, b).as_f64x4();
3291 transmute(simd_select_bitmask(k, min, f64x4::ZERO))
3292 }
3293}
3294
3295#[inline]
3299#[target_feature(enable = "avx512f,avx512vl")]
3300#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3301#[cfg_attr(test, assert_instr(vminpd))]
3302pub fn _mm_mask_min_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
3303 unsafe {
3304 let min = _mm_min_pd(a, b).as_f64x2();
3305 transmute(simd_select_bitmask(k, min, src.as_f64x2()))
3306 }
3307}
3308
3309#[inline]
3313#[target_feature(enable = "avx512f,avx512vl")]
3314#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3315#[cfg_attr(test, assert_instr(vminpd))]
3316pub fn _mm_maskz_min_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
3317 unsafe {
3318 let min = _mm_min_pd(a, b).as_f64x2();
3319 transmute(simd_select_bitmask(k, min, f64x2::ZERO))
3320 }
3321}
3322
3323#[inline]
3327#[target_feature(enable = "avx512f")]
3328#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3329#[cfg_attr(test, assert_instr(vpminud))]
3330#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3331pub const fn _mm512_min_epu32(a: __m512i, b: __m512i) -> __m512i {
3332 unsafe { simd_imin(a.as_u32x16(), b.as_u32x16()).as_m512i() }
3333}
3334
3335#[inline]
3339#[target_feature(enable = "avx512f")]
3340#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3341#[cfg_attr(test, assert_instr(vpminud))]
3342#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3343pub const fn _mm512_mask_min_epu32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
3344 unsafe {
3345 let min = _mm512_min_epu32(a, b).as_u32x16();
3346 transmute(simd_select_bitmask(k, min, src.as_u32x16()))
3347 }
3348}
3349
3350#[inline]
3354#[target_feature(enable = "avx512f")]
3355#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3356#[cfg_attr(test, assert_instr(vpminud))]
3357#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3358pub const fn _mm512_maskz_min_epu32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
3359 unsafe {
3360 let min = _mm512_min_epu32(a, b).as_u32x16();
3361 transmute(simd_select_bitmask(k, min, u32x16::ZERO))
3362 }
3363}
3364
3365#[inline]
3369#[target_feature(enable = "avx512f,avx512vl")]
3370#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3371#[cfg_attr(test, assert_instr(vpminud))]
3372#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3373pub const fn _mm256_mask_min_epu32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
3374 unsafe {
3375 let min = _mm256_min_epu32(a, b).as_u32x8();
3376 transmute(simd_select_bitmask(k, min, src.as_u32x8()))
3377 }
3378}
3379
3380#[inline]
3384#[target_feature(enable = "avx512f,avx512vl")]
3385#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3386#[cfg_attr(test, assert_instr(vpminud))]
3387#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3388pub const fn _mm256_maskz_min_epu32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
3389 unsafe {
3390 let min = _mm256_min_epu32(a, b).as_u32x8();
3391 transmute(simd_select_bitmask(k, min, u32x8::ZERO))
3392 }
3393}
3394
3395#[inline]
3399#[target_feature(enable = "avx512f,avx512vl")]
3400#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3401#[cfg_attr(test, assert_instr(vpminud))]
3402#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3403pub const fn _mm_mask_min_epu32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
3404 unsafe {
3405 let min = _mm_min_epu32(a, b).as_u32x4();
3406 transmute(simd_select_bitmask(k, min, src.as_u32x4()))
3407 }
3408}
3409
3410#[inline]
3414#[target_feature(enable = "avx512f,avx512vl")]
3415#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3416#[cfg_attr(test, assert_instr(vpminud))]
3417#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3418pub const fn _mm_maskz_min_epu32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
3419 unsafe {
3420 let min = _mm_min_epu32(a, b).as_u32x4();
3421 transmute(simd_select_bitmask(k, min, u32x4::ZERO))
3422 }
3423}
3424
3425#[inline]
3429#[target_feature(enable = "avx512f")]
3430#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3431#[cfg_attr(test, assert_instr(vpminuq))]
3432#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3433pub const fn _mm512_min_epu64(a: __m512i, b: __m512i) -> __m512i {
3434 unsafe { simd_imin(a.as_u64x8(), b.as_u64x8()).as_m512i() }
3435}
3436
3437#[inline]
3441#[target_feature(enable = "avx512f")]
3442#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3443#[cfg_attr(test, assert_instr(vpminuq))]
3444#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3445pub const fn _mm512_mask_min_epu64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
3446 unsafe {
3447 let min = _mm512_min_epu64(a, b).as_u64x8();
3448 transmute(simd_select_bitmask(k, min, src.as_u64x8()))
3449 }
3450}
3451
3452#[inline]
3456#[target_feature(enable = "avx512f")]
3457#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3458#[cfg_attr(test, assert_instr(vpminuq))]
3459#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3460pub const fn _mm512_maskz_min_epu64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
3461 unsafe {
3462 let min = _mm512_min_epu64(a, b).as_u64x8();
3463 transmute(simd_select_bitmask(k, min, u64x8::ZERO))
3464 }
3465}
3466
3467#[inline]
3471#[target_feature(enable = "avx512f,avx512vl")]
3472#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3473#[cfg_attr(test, assert_instr(vpminuq))]
3474#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3475pub const fn _mm256_min_epu64(a: __m256i, b: __m256i) -> __m256i {
3476 unsafe { simd_imin(a.as_u64x4(), b.as_u64x4()).as_m256i() }
3477}
3478
3479#[inline]
3483#[target_feature(enable = "avx512f,avx512vl")]
3484#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3485#[cfg_attr(test, assert_instr(vpminuq))]
3486#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3487pub const fn _mm256_mask_min_epu64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
3488 unsafe {
3489 let min = _mm256_min_epu64(a, b).as_u64x4();
3490 transmute(simd_select_bitmask(k, min, src.as_u64x4()))
3491 }
3492}
3493
3494#[inline]
3498#[target_feature(enable = "avx512f,avx512vl")]
3499#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3500#[cfg_attr(test, assert_instr(vpminuq))]
3501#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3502pub const fn _mm256_maskz_min_epu64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
3503 unsafe {
3504 let min = _mm256_min_epu64(a, b).as_u64x4();
3505 transmute(simd_select_bitmask(k, min, u64x4::ZERO))
3506 }
3507}
3508
3509#[inline]
3513#[target_feature(enable = "avx512f,avx512vl")]
3514#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3515#[cfg_attr(test, assert_instr(vpminuq))]
3516#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3517pub const fn _mm_min_epu64(a: __m128i, b: __m128i) -> __m128i {
3518 unsafe { simd_imin(a.as_u64x2(), b.as_u64x2()).as_m128i() }
3519}
3520
3521#[inline]
3525#[target_feature(enable = "avx512f,avx512vl")]
3526#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3527#[cfg_attr(test, assert_instr(vpminuq))]
3528#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3529pub const fn _mm_mask_min_epu64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
3530 unsafe {
3531 let min = _mm_min_epu64(a, b).as_u64x2();
3532 transmute(simd_select_bitmask(k, min, src.as_u64x2()))
3533 }
3534}
3535
3536#[inline]
3540#[target_feature(enable = "avx512f,avx512vl")]
3541#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3542#[cfg_attr(test, assert_instr(vpminuq))]
3543#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3544pub const fn _mm_maskz_min_epu64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
3545 unsafe {
3546 let min = _mm_min_epu64(a, b).as_u64x2();
3547 transmute(simd_select_bitmask(k, min, u64x2::ZERO))
3548 }
3549}
3550
3551#[inline]
3555#[target_feature(enable = "avx512f")]
3556#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3557#[cfg_attr(test, assert_instr(vsqrtps))]
3558pub fn _mm512_sqrt_ps(a: __m512) -> __m512 {
3559 unsafe { simd_fsqrt(a) }
3560}
3561
3562#[inline]
3566#[target_feature(enable = "avx512f")]
3567#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3568#[cfg_attr(test, assert_instr(vsqrtps))]
3569pub fn _mm512_mask_sqrt_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
3570 unsafe { simd_select_bitmask(k, simd_fsqrt(a), src) }
3571}
3572
3573#[inline]
3577#[target_feature(enable = "avx512f")]
3578#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3579#[cfg_attr(test, assert_instr(vsqrtps))]
3580pub fn _mm512_maskz_sqrt_ps(k: __mmask16, a: __m512) -> __m512 {
3581 unsafe { simd_select_bitmask(k, simd_fsqrt(a), _mm512_setzero_ps()) }
3582}
3583
3584#[inline]
3588#[target_feature(enable = "avx512f,avx512vl")]
3589#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3590#[cfg_attr(test, assert_instr(vsqrtps))]
3591pub fn _mm256_mask_sqrt_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
3592 unsafe { simd_select_bitmask(k, simd_fsqrt(a), src) }
3593}
3594
3595#[inline]
3599#[target_feature(enable = "avx512f,avx512vl")]
3600#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3601#[cfg_attr(test, assert_instr(vsqrtps))]
3602pub fn _mm256_maskz_sqrt_ps(k: __mmask8, a: __m256) -> __m256 {
3603 unsafe { simd_select_bitmask(k, simd_fsqrt(a), _mm256_setzero_ps()) }
3604}
3605
3606#[inline]
3610#[target_feature(enable = "avx512f,avx512vl")]
3611#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3612#[cfg_attr(test, assert_instr(vsqrtps))]
3613pub fn _mm_mask_sqrt_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
3614 unsafe { simd_select_bitmask(k, simd_fsqrt(a), src) }
3615}
3616
3617#[inline]
3621#[target_feature(enable = "avx512f,avx512vl")]
3622#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3623#[cfg_attr(test, assert_instr(vsqrtps))]
3624pub fn _mm_maskz_sqrt_ps(k: __mmask8, a: __m128) -> __m128 {
3625 unsafe { simd_select_bitmask(k, simd_fsqrt(a), _mm_setzero_ps()) }
3626}
3627
3628#[inline]
3632#[target_feature(enable = "avx512f")]
3633#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3634#[cfg_attr(test, assert_instr(vsqrtpd))]
3635pub fn _mm512_sqrt_pd(a: __m512d) -> __m512d {
3636 unsafe { simd_fsqrt(a) }
3637}
3638
3639#[inline]
3643#[target_feature(enable = "avx512f")]
3644#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3645#[cfg_attr(test, assert_instr(vsqrtpd))]
3646pub fn _mm512_mask_sqrt_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
3647 unsafe { simd_select_bitmask(k, simd_fsqrt(a), src) }
3648}
3649
3650#[inline]
3654#[target_feature(enable = "avx512f")]
3655#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3656#[cfg_attr(test, assert_instr(vsqrtpd))]
3657pub fn _mm512_maskz_sqrt_pd(k: __mmask8, a: __m512d) -> __m512d {
3658 unsafe { simd_select_bitmask(k, simd_fsqrt(a), _mm512_setzero_pd()) }
3659}
3660
3661#[inline]
3665#[target_feature(enable = "avx512f,avx512vl")]
3666#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3667#[cfg_attr(test, assert_instr(vsqrtpd))]
3668pub fn _mm256_mask_sqrt_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
3669 unsafe { simd_select_bitmask(k, simd_fsqrt(a), src) }
3670}
3671
3672#[inline]
3676#[target_feature(enable = "avx512f,avx512vl")]
3677#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3678#[cfg_attr(test, assert_instr(vsqrtpd))]
3679pub fn _mm256_maskz_sqrt_pd(k: __mmask8, a: __m256d) -> __m256d {
3680 unsafe { simd_select_bitmask(k, simd_fsqrt(a), _mm256_setzero_pd()) }
3681}
3682
3683#[inline]
3687#[target_feature(enable = "avx512f,avx512vl")]
3688#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3689#[cfg_attr(test, assert_instr(vsqrtpd))]
3690pub fn _mm_mask_sqrt_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
3691 unsafe { simd_select_bitmask(k, simd_fsqrt(a), src) }
3692}
3693
3694#[inline]
3698#[target_feature(enable = "avx512f,avx512vl")]
3699#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3700#[cfg_attr(test, assert_instr(vsqrtpd))]
3701pub fn _mm_maskz_sqrt_pd(k: __mmask8, a: __m128d) -> __m128d {
3702 unsafe { simd_select_bitmask(k, simd_fsqrt(a), _mm_setzero_pd()) }
3703}
3704
3705#[inline]
3709#[target_feature(enable = "avx512f")]
3710#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3711#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3713pub const fn _mm512_fmadd_ps(a: __m512, b: __m512, c: __m512) -> __m512 {
3714 unsafe { simd_fma(a, b, c) }
3715}
3716
3717#[inline]
3721#[target_feature(enable = "avx512f")]
3722#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3723#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3725pub const fn _mm512_mask_fmadd_ps(a: __m512, k: __mmask16, b: __m512, c: __m512) -> __m512 {
3726 unsafe { simd_select_bitmask(k, _mm512_fmadd_ps(a, b, c), a) }
3727}
3728
3729#[inline]
3733#[target_feature(enable = "avx512f")]
3734#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3735#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3737pub const fn _mm512_maskz_fmadd_ps(k: __mmask16, a: __m512, b: __m512, c: __m512) -> __m512 {
3738 unsafe { simd_select_bitmask(k, _mm512_fmadd_ps(a, b, c), _mm512_setzero_ps()) }
3739}
3740
3741#[inline]
3745#[target_feature(enable = "avx512f")]
3746#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3747#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3749pub const fn _mm512_mask3_fmadd_ps(a: __m512, b: __m512, c: __m512, k: __mmask16) -> __m512 {
3750 unsafe { simd_select_bitmask(k, _mm512_fmadd_ps(a, b, c), c) }
3751}
3752
3753#[inline]
3757#[target_feature(enable = "avx512f,avx512vl")]
3758#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3759#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3761pub const fn _mm256_mask_fmadd_ps(a: __m256, k: __mmask8, b: __m256, c: __m256) -> __m256 {
3762 unsafe { simd_select_bitmask(k, _mm256_fmadd_ps(a, b, c), a) }
3763}
3764
3765#[inline]
3769#[target_feature(enable = "avx512f,avx512vl")]
3770#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3771#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3773pub const fn _mm256_maskz_fmadd_ps(k: __mmask8, a: __m256, b: __m256, c: __m256) -> __m256 {
3774 unsafe { simd_select_bitmask(k, _mm256_fmadd_ps(a, b, c), _mm256_setzero_ps()) }
3775}
3776
3777#[inline]
3781#[target_feature(enable = "avx512f,avx512vl")]
3782#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3783#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3785pub const fn _mm256_mask3_fmadd_ps(a: __m256, b: __m256, c: __m256, k: __mmask8) -> __m256 {
3786 unsafe { simd_select_bitmask(k, _mm256_fmadd_ps(a, b, c), c) }
3787}
3788
3789#[inline]
3793#[target_feature(enable = "avx512f,avx512vl")]
3794#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3795#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3797pub const fn _mm_mask_fmadd_ps(a: __m128, k: __mmask8, b: __m128, c: __m128) -> __m128 {
3798 unsafe { simd_select_bitmask(k, _mm_fmadd_ps(a, b, c), a) }
3799}
3800
3801#[inline]
3805#[target_feature(enable = "avx512f,avx512vl")]
3806#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3807#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3809pub const fn _mm_maskz_fmadd_ps(k: __mmask8, a: __m128, b: __m128, c: __m128) -> __m128 {
3810 unsafe { simd_select_bitmask(k, _mm_fmadd_ps(a, b, c), _mm_setzero_ps()) }
3811}
3812
3813#[inline]
3817#[target_feature(enable = "avx512f,avx512vl")]
3818#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3819#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3821pub const fn _mm_mask3_fmadd_ps(a: __m128, b: __m128, c: __m128, k: __mmask8) -> __m128 {
3822 unsafe { simd_select_bitmask(k, _mm_fmadd_ps(a, b, c), c) }
3823}
3824
3825#[inline]
3829#[target_feature(enable = "avx512f")]
3830#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3831#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3833pub const fn _mm512_fmadd_pd(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
3834 unsafe { simd_fma(a, b, c) }
3835}
3836
3837#[inline]
3841#[target_feature(enable = "avx512f")]
3842#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3843#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3845pub const fn _mm512_mask_fmadd_pd(a: __m512d, k: __mmask8, b: __m512d, c: __m512d) -> __m512d {
3846 unsafe { simd_select_bitmask(k, _mm512_fmadd_pd(a, b, c), a) }
3847}
3848
3849#[inline]
3853#[target_feature(enable = "avx512f")]
3854#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3855#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3857pub const fn _mm512_maskz_fmadd_pd(k: __mmask8, a: __m512d, b: __m512d, c: __m512d) -> __m512d {
3858 unsafe { simd_select_bitmask(k, _mm512_fmadd_pd(a, b, c), _mm512_setzero_pd()) }
3859}
3860
3861#[inline]
3865#[target_feature(enable = "avx512f")]
3866#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3867#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3869pub const fn _mm512_mask3_fmadd_pd(a: __m512d, b: __m512d, c: __m512d, k: __mmask8) -> __m512d {
3870 unsafe { simd_select_bitmask(k, _mm512_fmadd_pd(a, b, c), c) }
3871}
3872
3873#[inline]
3877#[target_feature(enable = "avx512f,avx512vl")]
3878#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3879#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3881pub const fn _mm256_mask_fmadd_pd(a: __m256d, k: __mmask8, b: __m256d, c: __m256d) -> __m256d {
3882 unsafe { simd_select_bitmask(k, _mm256_fmadd_pd(a, b, c), a) }
3883}
3884
3885#[inline]
3889#[target_feature(enable = "avx512f,avx512vl")]
3890#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3891#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3893pub const fn _mm256_maskz_fmadd_pd(k: __mmask8, a: __m256d, b: __m256d, c: __m256d) -> __m256d {
3894 unsafe { simd_select_bitmask(k, _mm256_fmadd_pd(a, b, c), _mm256_setzero_pd()) }
3895}
3896
3897#[inline]
3901#[target_feature(enable = "avx512f,avx512vl")]
3902#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3903#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3905pub const fn _mm256_mask3_fmadd_pd(a: __m256d, b: __m256d, c: __m256d, k: __mmask8) -> __m256d {
3906 unsafe { simd_select_bitmask(k, _mm256_fmadd_pd(a, b, c), c) }
3907}
3908
3909#[inline]
3913#[target_feature(enable = "avx512f,avx512vl")]
3914#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3915#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3917pub const fn _mm_mask_fmadd_pd(a: __m128d, k: __mmask8, b: __m128d, c: __m128d) -> __m128d {
3918 unsafe { simd_select_bitmask(k, _mm_fmadd_pd(a, b, c), a) }
3919}
3920
3921#[inline]
3925#[target_feature(enable = "avx512f,avx512vl")]
3926#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3927#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3929pub const fn _mm_maskz_fmadd_pd(k: __mmask8, a: __m128d, b: __m128d, c: __m128d) -> __m128d {
3930 unsafe { simd_select_bitmask(k, _mm_fmadd_pd(a, b, c), _mm_setzero_pd()) }
3931}
3932
3933#[inline]
3937#[target_feature(enable = "avx512f,avx512vl")]
3938#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3939#[cfg_attr(test, assert_instr(vfmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3941pub const fn _mm_mask3_fmadd_pd(a: __m128d, b: __m128d, c: __m128d, k: __mmask8) -> __m128d {
3942 unsafe { simd_select_bitmask(k, _mm_fmadd_pd(a, b, c), c) }
3943}
3944
3945#[inline]
3949#[target_feature(enable = "avx512f")]
3950#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3951#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3953pub const fn _mm512_fmsub_ps(a: __m512, b: __m512, c: __m512) -> __m512 {
3954 unsafe { simd_fma(a, b, simd_neg(c)) }
3955}
3956
3957#[inline]
3961#[target_feature(enable = "avx512f")]
3962#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3963#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3965pub const fn _mm512_mask_fmsub_ps(a: __m512, k: __mmask16, b: __m512, c: __m512) -> __m512 {
3966 unsafe { simd_select_bitmask(k, _mm512_fmsub_ps(a, b, c), a) }
3967}
3968
3969#[inline]
3973#[target_feature(enable = "avx512f")]
3974#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3975#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3977pub const fn _mm512_maskz_fmsub_ps(k: __mmask16, a: __m512, b: __m512, c: __m512) -> __m512 {
3978 unsafe { simd_select_bitmask(k, _mm512_fmsub_ps(a, b, c), _mm512_setzero_ps()) }
3979}
3980
3981#[inline]
3985#[target_feature(enable = "avx512f")]
3986#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3987#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
3989pub const fn _mm512_mask3_fmsub_ps(a: __m512, b: __m512, c: __m512, k: __mmask16) -> __m512 {
3990 unsafe { simd_select_bitmask(k, _mm512_fmsub_ps(a, b, c), c) }
3991}
3992
3993#[inline]
3997#[target_feature(enable = "avx512f,avx512vl")]
3998#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
3999#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4001pub const fn _mm256_mask_fmsub_ps(a: __m256, k: __mmask8, b: __m256, c: __m256) -> __m256 {
4002 unsafe { simd_select_bitmask(k, _mm256_fmsub_ps(a, b, c), a) }
4003}
4004
4005#[inline]
4009#[target_feature(enable = "avx512f,avx512vl")]
4010#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4011#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4013pub const fn _mm256_maskz_fmsub_ps(k: __mmask8, a: __m256, b: __m256, c: __m256) -> __m256 {
4014 unsafe { simd_select_bitmask(k, _mm256_fmsub_ps(a, b, c), _mm256_setzero_ps()) }
4015}
4016
4017#[inline]
4021#[target_feature(enable = "avx512f,avx512vl")]
4022#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4023#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4025pub const fn _mm256_mask3_fmsub_ps(a: __m256, b: __m256, c: __m256, k: __mmask8) -> __m256 {
4026 unsafe { simd_select_bitmask(k, _mm256_fmsub_ps(a, b, c), c) }
4027}
4028
4029#[inline]
4033#[target_feature(enable = "avx512f,avx512vl")]
4034#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4035#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4037pub const fn _mm_mask_fmsub_ps(a: __m128, k: __mmask8, b: __m128, c: __m128) -> __m128 {
4038 unsafe { simd_select_bitmask(k, _mm_fmsub_ps(a, b, c), a) }
4039}
4040
4041#[inline]
4045#[target_feature(enable = "avx512f,avx512vl")]
4046#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4047#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4049pub const fn _mm_maskz_fmsub_ps(k: __mmask8, a: __m128, b: __m128, c: __m128) -> __m128 {
4050 unsafe { simd_select_bitmask(k, _mm_fmsub_ps(a, b, c), _mm_setzero_ps()) }
4051}
4052
4053#[inline]
4057#[target_feature(enable = "avx512f,avx512vl")]
4058#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4059#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4061pub const fn _mm_mask3_fmsub_ps(a: __m128, b: __m128, c: __m128, k: __mmask8) -> __m128 {
4062 unsafe { simd_select_bitmask(k, _mm_fmsub_ps(a, b, c), c) }
4063}
4064
4065#[inline]
4069#[target_feature(enable = "avx512f")]
4070#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4071#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4073pub const fn _mm512_fmsub_pd(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4074 unsafe { simd_fma(a, b, simd_neg(c)) }
4075}
4076
4077#[inline]
4081#[target_feature(enable = "avx512f")]
4082#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4083#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4085pub const fn _mm512_mask_fmsub_pd(a: __m512d, k: __mmask8, b: __m512d, c: __m512d) -> __m512d {
4086 unsafe { simd_select_bitmask(k, _mm512_fmsub_pd(a, b, c), a) }
4087}
4088
4089#[inline]
4093#[target_feature(enable = "avx512f")]
4094#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4095#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4097pub const fn _mm512_maskz_fmsub_pd(k: __mmask8, a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4098 unsafe { simd_select_bitmask(k, _mm512_fmsub_pd(a, b, c), _mm512_setzero_pd()) }
4099}
4100
4101#[inline]
4105#[target_feature(enable = "avx512f")]
4106#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4107#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4109pub const fn _mm512_mask3_fmsub_pd(a: __m512d, b: __m512d, c: __m512d, k: __mmask8) -> __m512d {
4110 unsafe { simd_select_bitmask(k, _mm512_fmsub_pd(a, b, c), c) }
4111}
4112
4113#[inline]
4117#[target_feature(enable = "avx512f,avx512vl")]
4118#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4119#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4121pub const fn _mm256_mask_fmsub_pd(a: __m256d, k: __mmask8, b: __m256d, c: __m256d) -> __m256d {
4122 unsafe { simd_select_bitmask(k, _mm256_fmsub_pd(a, b, c), a) }
4123}
4124
4125#[inline]
4129#[target_feature(enable = "avx512f,avx512vl")]
4130#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4131#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4133pub const fn _mm256_maskz_fmsub_pd(k: __mmask8, a: __m256d, b: __m256d, c: __m256d) -> __m256d {
4134 unsafe { simd_select_bitmask(k, _mm256_fmsub_pd(a, b, c), _mm256_setzero_pd()) }
4135}
4136
4137#[inline]
4141#[target_feature(enable = "avx512f,avx512vl")]
4142#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4143#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4145pub const fn _mm256_mask3_fmsub_pd(a: __m256d, b: __m256d, c: __m256d, k: __mmask8) -> __m256d {
4146 unsafe { simd_select_bitmask(k, _mm256_fmsub_pd(a, b, c), c) }
4147}
4148
4149#[inline]
4153#[target_feature(enable = "avx512f,avx512vl")]
4154#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4155#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4157pub const fn _mm_mask_fmsub_pd(a: __m128d, k: __mmask8, b: __m128d, c: __m128d) -> __m128d {
4158 unsafe { simd_select_bitmask(k, _mm_fmsub_pd(a, b, c), a) }
4159}
4160
4161#[inline]
4165#[target_feature(enable = "avx512f,avx512vl")]
4166#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4167#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4169pub const fn _mm_maskz_fmsub_pd(k: __mmask8, a: __m128d, b: __m128d, c: __m128d) -> __m128d {
4170 unsafe { simd_select_bitmask(k, _mm_fmsub_pd(a, b, c), _mm_setzero_pd()) }
4171}
4172
4173#[inline]
4177#[target_feature(enable = "avx512f,avx512vl")]
4178#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4179#[cfg_attr(test, assert_instr(vfmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4181pub const fn _mm_mask3_fmsub_pd(a: __m128d, b: __m128d, c: __m128d, k: __mmask8) -> __m128d {
4182 unsafe { simd_select_bitmask(k, _mm_fmsub_pd(a, b, c), c) }
4183}
4184
4185#[inline]
4189#[target_feature(enable = "avx512f")]
4190#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4191#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4193pub const fn _mm512_fmaddsub_ps(a: __m512, b: __m512, c: __m512) -> __m512 {
4194 unsafe {
4195 let add = simd_fma(a, b, c);
4196 let sub = simd_fma(a, b, simd_neg(c));
4197 simd_shuffle!(
4198 add,
4199 sub,
4200 [16, 1, 18, 3, 20, 5, 22, 7, 24, 9, 26, 11, 28, 13, 30, 15]
4201 )
4202 }
4203}
4204
4205#[inline]
4209#[target_feature(enable = "avx512f")]
4210#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4211#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4213pub const fn _mm512_mask_fmaddsub_ps(a: __m512, k: __mmask16, b: __m512, c: __m512) -> __m512 {
4214 unsafe { simd_select_bitmask(k, _mm512_fmaddsub_ps(a, b, c), a) }
4215}
4216
4217#[inline]
4221#[target_feature(enable = "avx512f")]
4222#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4223#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4225pub const fn _mm512_maskz_fmaddsub_ps(k: __mmask16, a: __m512, b: __m512, c: __m512) -> __m512 {
4226 unsafe { simd_select_bitmask(k, _mm512_fmaddsub_ps(a, b, c), _mm512_setzero_ps()) }
4227}
4228
4229#[inline]
4233#[target_feature(enable = "avx512f")]
4234#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4235#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4237pub const fn _mm512_mask3_fmaddsub_ps(a: __m512, b: __m512, c: __m512, k: __mmask16) -> __m512 {
4238 unsafe { simd_select_bitmask(k, _mm512_fmaddsub_ps(a, b, c), c) }
4239}
4240
4241#[inline]
4245#[target_feature(enable = "avx512f,avx512vl")]
4246#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4247#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4249pub const fn _mm256_mask_fmaddsub_ps(a: __m256, k: __mmask8, b: __m256, c: __m256) -> __m256 {
4250 unsafe { simd_select_bitmask(k, _mm256_fmaddsub_ps(a, b, c), a) }
4251}
4252
4253#[inline]
4257#[target_feature(enable = "avx512f,avx512vl")]
4258#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4259#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4261pub const fn _mm256_maskz_fmaddsub_ps(k: __mmask8, a: __m256, b: __m256, c: __m256) -> __m256 {
4262 unsafe { simd_select_bitmask(k, _mm256_fmaddsub_ps(a, b, c), _mm256_setzero_ps()) }
4263}
4264
4265#[inline]
4269#[target_feature(enable = "avx512f,avx512vl")]
4270#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4271#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4273pub const fn _mm256_mask3_fmaddsub_ps(a: __m256, b: __m256, c: __m256, k: __mmask8) -> __m256 {
4274 unsafe { simd_select_bitmask(k, _mm256_fmaddsub_ps(a, b, c), c) }
4275}
4276
4277#[inline]
4281#[target_feature(enable = "avx512f,avx512vl")]
4282#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4283#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4285pub const fn _mm_mask_fmaddsub_ps(a: __m128, k: __mmask8, b: __m128, c: __m128) -> __m128 {
4286 unsafe { simd_select_bitmask(k, _mm_fmaddsub_ps(a, b, c), a) }
4287}
4288
4289#[inline]
4293#[target_feature(enable = "avx512f,avx512vl")]
4294#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4295#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4297pub const fn _mm_maskz_fmaddsub_ps(k: __mmask8, a: __m128, b: __m128, c: __m128) -> __m128 {
4298 unsafe { simd_select_bitmask(k, _mm_fmaddsub_ps(a, b, c), _mm_setzero_ps()) }
4299}
4300
4301#[inline]
4305#[target_feature(enable = "avx512f,avx512vl")]
4306#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4307#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4309pub const fn _mm_mask3_fmaddsub_ps(a: __m128, b: __m128, c: __m128, k: __mmask8) -> __m128 {
4310 unsafe { simd_select_bitmask(k, _mm_fmaddsub_ps(a, b, c), c) }
4311}
4312
4313#[inline]
4317#[target_feature(enable = "avx512f")]
4318#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4319#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4321pub const fn _mm512_fmaddsub_pd(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4322 unsafe {
4323 let add = simd_fma(a, b, c);
4324 let sub = simd_fma(a, b, simd_neg(c));
4325 simd_shuffle!(add, sub, [8, 1, 10, 3, 12, 5, 14, 7])
4326 }
4327}
4328
4329#[inline]
4333#[target_feature(enable = "avx512f")]
4334#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4335#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4337pub const fn _mm512_mask_fmaddsub_pd(a: __m512d, k: __mmask8, b: __m512d, c: __m512d) -> __m512d {
4338 unsafe { simd_select_bitmask(k, _mm512_fmaddsub_pd(a, b, c), a) }
4339}
4340
4341#[inline]
4345#[target_feature(enable = "avx512f")]
4346#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4347#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4349pub const fn _mm512_maskz_fmaddsub_pd(k: __mmask8, a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4350 unsafe { simd_select_bitmask(k, _mm512_fmaddsub_pd(a, b, c), _mm512_setzero_pd()) }
4351}
4352
4353#[inline]
4357#[target_feature(enable = "avx512f")]
4358#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4359#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4361pub const fn _mm512_mask3_fmaddsub_pd(a: __m512d, b: __m512d, c: __m512d, k: __mmask8) -> __m512d {
4362 unsafe { simd_select_bitmask(k, _mm512_fmaddsub_pd(a, b, c), c) }
4363}
4364
4365#[inline]
4369#[target_feature(enable = "avx512f,avx512vl")]
4370#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4371#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4373pub const fn _mm256_mask_fmaddsub_pd(a: __m256d, k: __mmask8, b: __m256d, c: __m256d) -> __m256d {
4374 unsafe { simd_select_bitmask(k, _mm256_fmaddsub_pd(a, b, c), a) }
4375}
4376
4377#[inline]
4381#[target_feature(enable = "avx512f,avx512vl")]
4382#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4383#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4385pub const fn _mm256_maskz_fmaddsub_pd(k: __mmask8, a: __m256d, b: __m256d, c: __m256d) -> __m256d {
4386 unsafe { simd_select_bitmask(k, _mm256_fmaddsub_pd(a, b, c), _mm256_setzero_pd()) }
4387}
4388
4389#[inline]
4393#[target_feature(enable = "avx512f,avx512vl")]
4394#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4395#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4397pub const fn _mm256_mask3_fmaddsub_pd(a: __m256d, b: __m256d, c: __m256d, k: __mmask8) -> __m256d {
4398 unsafe { simd_select_bitmask(k, _mm256_fmaddsub_pd(a, b, c), c) }
4399}
4400
4401#[inline]
4405#[target_feature(enable = "avx512f,avx512vl")]
4406#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4407#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4409pub const fn _mm_mask_fmaddsub_pd(a: __m128d, k: __mmask8, b: __m128d, c: __m128d) -> __m128d {
4410 unsafe { simd_select_bitmask(k, _mm_fmaddsub_pd(a, b, c), a) }
4411}
4412
4413#[inline]
4417#[target_feature(enable = "avx512f,avx512vl")]
4418#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4419#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4421pub const fn _mm_maskz_fmaddsub_pd(k: __mmask8, a: __m128d, b: __m128d, c: __m128d) -> __m128d {
4422 unsafe { simd_select_bitmask(k, _mm_fmaddsub_pd(a, b, c), _mm_setzero_pd()) }
4423}
4424
4425#[inline]
4429#[target_feature(enable = "avx512f,avx512vl")]
4430#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4431#[cfg_attr(test, assert_instr(vfmaddsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4433pub const fn _mm_mask3_fmaddsub_pd(a: __m128d, b: __m128d, c: __m128d, k: __mmask8) -> __m128d {
4434 unsafe { simd_select_bitmask(k, _mm_fmaddsub_pd(a, b, c), c) }
4435}
4436
4437#[inline]
4441#[target_feature(enable = "avx512f")]
4442#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4443#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4445pub const fn _mm512_fmsubadd_ps(a: __m512, b: __m512, c: __m512) -> __m512 {
4446 unsafe {
4447 let add = simd_fma(a, b, c);
4448 let sub = simd_fma(a, b, simd_neg(c));
4449 simd_shuffle!(
4450 add,
4451 sub,
4452 [0, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 29, 14, 31]
4453 )
4454 }
4455}
4456
4457#[inline]
4461#[target_feature(enable = "avx512f")]
4462#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4463#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4465pub const fn _mm512_mask_fmsubadd_ps(a: __m512, k: __mmask16, b: __m512, c: __m512) -> __m512 {
4466 unsafe { simd_select_bitmask(k, _mm512_fmsubadd_ps(a, b, c), a) }
4467}
4468
4469#[inline]
4473#[target_feature(enable = "avx512f")]
4474#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4475#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4477pub const fn _mm512_maskz_fmsubadd_ps(k: __mmask16, a: __m512, b: __m512, c: __m512) -> __m512 {
4478 unsafe { simd_select_bitmask(k, _mm512_fmsubadd_ps(a, b, c), _mm512_setzero_ps()) }
4479}
4480
4481#[inline]
4485#[target_feature(enable = "avx512f")]
4486#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4487#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4489pub const fn _mm512_mask3_fmsubadd_ps(a: __m512, b: __m512, c: __m512, k: __mmask16) -> __m512 {
4490 unsafe { simd_select_bitmask(k, _mm512_fmsubadd_ps(a, b, c), c) }
4491}
4492
4493#[inline]
4497#[target_feature(enable = "avx512f,avx512vl")]
4498#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4499#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4501pub const fn _mm256_mask_fmsubadd_ps(a: __m256, k: __mmask8, b: __m256, c: __m256) -> __m256 {
4502 unsafe { simd_select_bitmask(k, _mm256_fmsubadd_ps(a, b, c), a) }
4503}
4504
4505#[inline]
4509#[target_feature(enable = "avx512f,avx512vl")]
4510#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4511#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4513pub const fn _mm256_maskz_fmsubadd_ps(k: __mmask8, a: __m256, b: __m256, c: __m256) -> __m256 {
4514 unsafe { simd_select_bitmask(k, _mm256_fmsubadd_ps(a, b, c), _mm256_setzero_ps()) }
4515}
4516
4517#[inline]
4521#[target_feature(enable = "avx512f,avx512vl")]
4522#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4523#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4525pub const fn _mm256_mask3_fmsubadd_ps(a: __m256, b: __m256, c: __m256, k: __mmask8) -> __m256 {
4526 unsafe { simd_select_bitmask(k, _mm256_fmsubadd_ps(a, b, c), c) }
4527}
4528
4529#[inline]
4533#[target_feature(enable = "avx512f,avx512vl")]
4534#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4535#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4537pub const fn _mm_mask_fmsubadd_ps(a: __m128, k: __mmask8, b: __m128, c: __m128) -> __m128 {
4538 unsafe { simd_select_bitmask(k, _mm_fmsubadd_ps(a, b, c), a) }
4539}
4540
4541#[inline]
4545#[target_feature(enable = "avx512f,avx512vl")]
4546#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4547#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4549pub const fn _mm_maskz_fmsubadd_ps(k: __mmask8, a: __m128, b: __m128, c: __m128) -> __m128 {
4550 unsafe { simd_select_bitmask(k, _mm_fmsubadd_ps(a, b, c), _mm_setzero_ps()) }
4551}
4552
4553#[inline]
4557#[target_feature(enable = "avx512f,avx512vl")]
4558#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4559#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4561pub const fn _mm_mask3_fmsubadd_ps(a: __m128, b: __m128, c: __m128, k: __mmask8) -> __m128 {
4562 unsafe { simd_select_bitmask(k, _mm_fmsubadd_ps(a, b, c), c) }
4563}
4564
4565#[inline]
4569#[target_feature(enable = "avx512f")]
4570#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4571#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4573pub const fn _mm512_fmsubadd_pd(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4574 unsafe {
4575 let add = simd_fma(a, b, c);
4576 let sub = simd_fma(a, b, simd_neg(c));
4577 simd_shuffle!(add, sub, [0, 9, 2, 11, 4, 13, 6, 15])
4578 }
4579}
4580
4581#[inline]
4585#[target_feature(enable = "avx512f")]
4586#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4587#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4589pub const fn _mm512_mask_fmsubadd_pd(a: __m512d, k: __mmask8, b: __m512d, c: __m512d) -> __m512d {
4590 unsafe { simd_select_bitmask(k, _mm512_fmsubadd_pd(a, b, c), a) }
4591}
4592
4593#[inline]
4597#[target_feature(enable = "avx512f")]
4598#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4599#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4601pub const fn _mm512_maskz_fmsubadd_pd(k: __mmask8, a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4602 unsafe { simd_select_bitmask(k, _mm512_fmsubadd_pd(a, b, c), _mm512_setzero_pd()) }
4603}
4604
4605#[inline]
4609#[target_feature(enable = "avx512f")]
4610#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4611#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4613pub const fn _mm512_mask3_fmsubadd_pd(a: __m512d, b: __m512d, c: __m512d, k: __mmask8) -> __m512d {
4614 unsafe { simd_select_bitmask(k, _mm512_fmsubadd_pd(a, b, c), c) }
4615}
4616
4617#[inline]
4621#[target_feature(enable = "avx512f,avx512vl")]
4622#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4623#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4625pub const fn _mm256_mask_fmsubadd_pd(a: __m256d, k: __mmask8, b: __m256d, c: __m256d) -> __m256d {
4626 unsafe { simd_select_bitmask(k, _mm256_fmsubadd_pd(a, b, c), a) }
4627}
4628
4629#[inline]
4633#[target_feature(enable = "avx512f,avx512vl")]
4634#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4635#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4637pub const fn _mm256_maskz_fmsubadd_pd(k: __mmask8, a: __m256d, b: __m256d, c: __m256d) -> __m256d {
4638 unsafe { simd_select_bitmask(k, _mm256_fmsubadd_pd(a, b, c), _mm256_setzero_pd()) }
4639}
4640
4641#[inline]
4645#[target_feature(enable = "avx512f,avx512vl")]
4646#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4647#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4649pub const fn _mm256_mask3_fmsubadd_pd(a: __m256d, b: __m256d, c: __m256d, k: __mmask8) -> __m256d {
4650 unsafe { simd_select_bitmask(k, _mm256_fmsubadd_pd(a, b, c), c) }
4651}
4652
4653#[inline]
4657#[target_feature(enable = "avx512f,avx512vl")]
4658#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4659#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4661pub const fn _mm_mask_fmsubadd_pd(a: __m128d, k: __mmask8, b: __m128d, c: __m128d) -> __m128d {
4662 unsafe { simd_select_bitmask(k, _mm_fmsubadd_pd(a, b, c), a) }
4663}
4664
4665#[inline]
4669#[target_feature(enable = "avx512f,avx512vl")]
4670#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4671#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4673pub const fn _mm_maskz_fmsubadd_pd(k: __mmask8, a: __m128d, b: __m128d, c: __m128d) -> __m128d {
4674 unsafe { simd_select_bitmask(k, _mm_fmsubadd_pd(a, b, c), _mm_setzero_pd()) }
4675}
4676
4677#[inline]
4681#[target_feature(enable = "avx512f,avx512vl")]
4682#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4683#[cfg_attr(test, assert_instr(vfmsubadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4685pub const fn _mm_mask3_fmsubadd_pd(a: __m128d, b: __m128d, c: __m128d, k: __mmask8) -> __m128d {
4686 unsafe { simd_select_bitmask(k, _mm_fmsubadd_pd(a, b, c), c) }
4687}
4688
4689#[inline]
4693#[target_feature(enable = "avx512f")]
4694#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4695#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4697pub const fn _mm512_fnmadd_ps(a: __m512, b: __m512, c: __m512) -> __m512 {
4698 unsafe { simd_fma(simd_neg(a), b, c) }
4699}
4700
4701#[inline]
4705#[target_feature(enable = "avx512f")]
4706#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4707#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4709pub const fn _mm512_mask_fnmadd_ps(a: __m512, k: __mmask16, b: __m512, c: __m512) -> __m512 {
4710 unsafe { simd_select_bitmask(k, _mm512_fnmadd_ps(a, b, c), a) }
4711}
4712
4713#[inline]
4717#[target_feature(enable = "avx512f")]
4718#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4719#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4721pub const fn _mm512_maskz_fnmadd_ps(k: __mmask16, a: __m512, b: __m512, c: __m512) -> __m512 {
4722 unsafe { simd_select_bitmask(k, _mm512_fnmadd_ps(a, b, c), _mm512_setzero_ps()) }
4723}
4724
4725#[inline]
4729#[target_feature(enable = "avx512f")]
4730#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4731#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4733pub const fn _mm512_mask3_fnmadd_ps(a: __m512, b: __m512, c: __m512, k: __mmask16) -> __m512 {
4734 unsafe { simd_select_bitmask(k, _mm512_fnmadd_ps(a, b, c), c) }
4735}
4736
4737#[inline]
4741#[target_feature(enable = "avx512f,avx512vl")]
4742#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4743#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4745pub const fn _mm256_mask_fnmadd_ps(a: __m256, k: __mmask8, b: __m256, c: __m256) -> __m256 {
4746 unsafe { simd_select_bitmask(k, _mm256_fnmadd_ps(a, b, c), a) }
4747}
4748
4749#[inline]
4753#[target_feature(enable = "avx512f,avx512vl")]
4754#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4755#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4757pub const fn _mm256_maskz_fnmadd_ps(k: __mmask8, a: __m256, b: __m256, c: __m256) -> __m256 {
4758 unsafe { simd_select_bitmask(k, _mm256_fnmadd_ps(a, b, c), _mm256_setzero_ps()) }
4759}
4760
4761#[inline]
4765#[target_feature(enable = "avx512f,avx512vl")]
4766#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4767#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4769pub const fn _mm256_mask3_fnmadd_ps(a: __m256, b: __m256, c: __m256, k: __mmask8) -> __m256 {
4770 unsafe { simd_select_bitmask(k, _mm256_fnmadd_ps(a, b, c), c) }
4771}
4772
4773#[inline]
4777#[target_feature(enable = "avx512f,avx512vl")]
4778#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4779#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4781pub const fn _mm_mask_fnmadd_ps(a: __m128, k: __mmask8, b: __m128, c: __m128) -> __m128 {
4782 unsafe { simd_select_bitmask(k, _mm_fnmadd_ps(a, b, c), a) }
4783}
4784
4785#[inline]
4789#[target_feature(enable = "avx512f,avx512vl")]
4790#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4791#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4793pub const fn _mm_maskz_fnmadd_ps(k: __mmask8, a: __m128, b: __m128, c: __m128) -> __m128 {
4794 unsafe { simd_select_bitmask(k, _mm_fnmadd_ps(a, b, c), _mm_setzero_ps()) }
4795}
4796
4797#[inline]
4801#[target_feature(enable = "avx512f,avx512vl")]
4802#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4803#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4805pub const fn _mm_mask3_fnmadd_ps(a: __m128, b: __m128, c: __m128, k: __mmask8) -> __m128 {
4806 unsafe { simd_select_bitmask(k, _mm_fnmadd_ps(a, b, c), c) }
4807}
4808
4809#[inline]
4813#[target_feature(enable = "avx512f")]
4814#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4815#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4817pub const fn _mm512_fnmadd_pd(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4818 unsafe { simd_fma(simd_neg(a), b, c) }
4819}
4820
4821#[inline]
4825#[target_feature(enable = "avx512f")]
4826#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4827#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4829pub const fn _mm512_mask_fnmadd_pd(a: __m512d, k: __mmask8, b: __m512d, c: __m512d) -> __m512d {
4830 unsafe { simd_select_bitmask(k, _mm512_fnmadd_pd(a, b, c), a) }
4831}
4832
4833#[inline]
4837#[target_feature(enable = "avx512f")]
4838#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4839#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4841pub const fn _mm512_maskz_fnmadd_pd(k: __mmask8, a: __m512d, b: __m512d, c: __m512d) -> __m512d {
4842 unsafe { simd_select_bitmask(k, _mm512_fnmadd_pd(a, b, c), _mm512_setzero_pd()) }
4843}
4844
4845#[inline]
4849#[target_feature(enable = "avx512f")]
4850#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4851#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4853pub const fn _mm512_mask3_fnmadd_pd(a: __m512d, b: __m512d, c: __m512d, k: __mmask8) -> __m512d {
4854 unsafe { simd_select_bitmask(k, _mm512_fnmadd_pd(a, b, c), c) }
4855}
4856
4857#[inline]
4861#[target_feature(enable = "avx512f,avx512vl")]
4862#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4863#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4865pub const fn _mm256_mask_fnmadd_pd(a: __m256d, k: __mmask8, b: __m256d, c: __m256d) -> __m256d {
4866 unsafe { simd_select_bitmask(k, _mm256_fnmadd_pd(a, b, c), a) }
4867}
4868
4869#[inline]
4873#[target_feature(enable = "avx512f,avx512vl")]
4874#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4875#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4877pub const fn _mm256_maskz_fnmadd_pd(k: __mmask8, a: __m256d, b: __m256d, c: __m256d) -> __m256d {
4878 unsafe { simd_select_bitmask(k, _mm256_fnmadd_pd(a, b, c), _mm256_setzero_pd()) }
4879}
4880
4881#[inline]
4885#[target_feature(enable = "avx512f,avx512vl")]
4886#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4887#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4889pub const fn _mm256_mask3_fnmadd_pd(a: __m256d, b: __m256d, c: __m256d, k: __mmask8) -> __m256d {
4890 unsafe { simd_select_bitmask(k, _mm256_fnmadd_pd(a, b, c), c) }
4891}
4892
4893#[inline]
4897#[target_feature(enable = "avx512f,avx512vl")]
4898#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4899#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4901pub const fn _mm_mask_fnmadd_pd(a: __m128d, k: __mmask8, b: __m128d, c: __m128d) -> __m128d {
4902 unsafe { simd_select_bitmask(k, _mm_fnmadd_pd(a, b, c), a) }
4903}
4904
4905#[inline]
4909#[target_feature(enable = "avx512f,avx512vl")]
4910#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4911#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4913pub const fn _mm_maskz_fnmadd_pd(k: __mmask8, a: __m128d, b: __m128d, c: __m128d) -> __m128d {
4914 unsafe { simd_select_bitmask(k, _mm_fnmadd_pd(a, b, c), _mm_setzero_pd()) }
4915}
4916
4917#[inline]
4921#[target_feature(enable = "avx512f,avx512vl")]
4922#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4923#[cfg_attr(test, assert_instr(vfnmadd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4925pub const fn _mm_mask3_fnmadd_pd(a: __m128d, b: __m128d, c: __m128d, k: __mmask8) -> __m128d {
4926 unsafe { simd_select_bitmask(k, _mm_fnmadd_pd(a, b, c), c) }
4927}
4928
4929#[inline]
4933#[target_feature(enable = "avx512f")]
4934#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4935#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4937pub const fn _mm512_fnmsub_ps(a: __m512, b: __m512, c: __m512) -> __m512 {
4938 unsafe { simd_fma(simd_neg(a), b, simd_neg(c)) }
4939}
4940
4941#[inline]
4945#[target_feature(enable = "avx512f")]
4946#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4947#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4949pub const fn _mm512_mask_fnmsub_ps(a: __m512, k: __mmask16, b: __m512, c: __m512) -> __m512 {
4950 unsafe { simd_select_bitmask(k, _mm512_fnmsub_ps(a, b, c), a) }
4951}
4952
4953#[inline]
4957#[target_feature(enable = "avx512f")]
4958#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4959#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4961pub const fn _mm512_maskz_fnmsub_ps(k: __mmask16, a: __m512, b: __m512, c: __m512) -> __m512 {
4962 unsafe { simd_select_bitmask(k, _mm512_fnmsub_ps(a, b, c), _mm512_setzero_ps()) }
4963}
4964
4965#[inline]
4969#[target_feature(enable = "avx512f")]
4970#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4971#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4973pub const fn _mm512_mask3_fnmsub_ps(a: __m512, b: __m512, c: __m512, k: __mmask16) -> __m512 {
4974 unsafe { simd_select_bitmask(k, _mm512_fnmsub_ps(a, b, c), c) }
4975}
4976
4977#[inline]
4981#[target_feature(enable = "avx512f,avx512vl")]
4982#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4983#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4985pub const fn _mm256_mask_fnmsub_ps(a: __m256, k: __mmask8, b: __m256, c: __m256) -> __m256 {
4986 unsafe { simd_select_bitmask(k, _mm256_fnmsub_ps(a, b, c), a) }
4987}
4988
4989#[inline]
4993#[target_feature(enable = "avx512f,avx512vl")]
4994#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
4995#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
4997pub const fn _mm256_maskz_fnmsub_ps(k: __mmask8, a: __m256, b: __m256, c: __m256) -> __m256 {
4998 unsafe { simd_select_bitmask(k, _mm256_fnmsub_ps(a, b, c), _mm256_setzero_ps()) }
4999}
5000
5001#[inline]
5005#[target_feature(enable = "avx512f,avx512vl")]
5006#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5007#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5009pub const fn _mm256_mask3_fnmsub_ps(a: __m256, b: __m256, c: __m256, k: __mmask8) -> __m256 {
5010 unsafe { simd_select_bitmask(k, _mm256_fnmsub_ps(a, b, c), c) }
5011}
5012
5013#[inline]
5017#[target_feature(enable = "avx512f,avx512vl")]
5018#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5019#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5021pub const fn _mm_mask_fnmsub_ps(a: __m128, k: __mmask8, b: __m128, c: __m128) -> __m128 {
5022 unsafe { simd_select_bitmask(k, _mm_fnmsub_ps(a, b, c), a) }
5023}
5024
5025#[inline]
5029#[target_feature(enable = "avx512f,avx512vl")]
5030#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5031#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5033pub const fn _mm_maskz_fnmsub_ps(k: __mmask8, a: __m128, b: __m128, c: __m128) -> __m128 {
5034 unsafe { simd_select_bitmask(k, _mm_fnmsub_ps(a, b, c), _mm_setzero_ps()) }
5035}
5036
5037#[inline]
5041#[target_feature(enable = "avx512f,avx512vl")]
5042#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5043#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5045pub const fn _mm_mask3_fnmsub_ps(a: __m128, b: __m128, c: __m128, k: __mmask8) -> __m128 {
5046 unsafe { simd_select_bitmask(k, _mm_fnmsub_ps(a, b, c), c) }
5047}
5048
5049#[inline]
5053#[target_feature(enable = "avx512f")]
5054#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5055#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5057pub const fn _mm512_fnmsub_pd(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
5058 unsafe { simd_fma(simd_neg(a), b, simd_neg(c)) }
5059}
5060
5061#[inline]
5065#[target_feature(enable = "avx512f")]
5066#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5067#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5069pub const fn _mm512_mask_fnmsub_pd(a: __m512d, k: __mmask8, b: __m512d, c: __m512d) -> __m512d {
5070 unsafe { simd_select_bitmask(k, _mm512_fnmsub_pd(a, b, c), a) }
5071}
5072
5073#[inline]
5077#[target_feature(enable = "avx512f")]
5078#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5079#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5081pub const fn _mm512_maskz_fnmsub_pd(k: __mmask8, a: __m512d, b: __m512d, c: __m512d) -> __m512d {
5082 unsafe { simd_select_bitmask(k, _mm512_fnmsub_pd(a, b, c), _mm512_setzero_pd()) }
5083}
5084
5085#[inline]
5089#[target_feature(enable = "avx512f")]
5090#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5091#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5093pub const fn _mm512_mask3_fnmsub_pd(a: __m512d, b: __m512d, c: __m512d, k: __mmask8) -> __m512d {
5094 unsafe { simd_select_bitmask(k, _mm512_fnmsub_pd(a, b, c), c) }
5095}
5096
5097#[inline]
5101#[target_feature(enable = "avx512f,avx512vl")]
5102#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5103#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5105pub const fn _mm256_mask_fnmsub_pd(a: __m256d, k: __mmask8, b: __m256d, c: __m256d) -> __m256d {
5106 unsafe { simd_select_bitmask(k, _mm256_fnmsub_pd(a, b, c), a) }
5107}
5108
5109#[inline]
5113#[target_feature(enable = "avx512f,avx512vl")]
5114#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5115#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5117pub const fn _mm256_maskz_fnmsub_pd(k: __mmask8, a: __m256d, b: __m256d, c: __m256d) -> __m256d {
5118 unsafe { simd_select_bitmask(k, _mm256_fnmsub_pd(a, b, c), _mm256_setzero_pd()) }
5119}
5120
5121#[inline]
5125#[target_feature(enable = "avx512f,avx512vl")]
5126#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5127#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5129pub const fn _mm256_mask3_fnmsub_pd(a: __m256d, b: __m256d, c: __m256d, k: __mmask8) -> __m256d {
5130 unsafe { simd_select_bitmask(k, _mm256_fnmsub_pd(a, b, c), c) }
5131}
5132
5133#[inline]
5137#[target_feature(enable = "avx512f,avx512vl")]
5138#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5139#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5141pub const fn _mm_mask_fnmsub_pd(a: __m128d, k: __mmask8, b: __m128d, c: __m128d) -> __m128d {
5142 unsafe { simd_select_bitmask(k, _mm_fnmsub_pd(a, b, c), a) }
5143}
5144
5145#[inline]
5149#[target_feature(enable = "avx512f,avx512vl")]
5150#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5151#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5153pub const fn _mm_maskz_fnmsub_pd(k: __mmask8, a: __m128d, b: __m128d, c: __m128d) -> __m128d {
5154 unsafe { simd_select_bitmask(k, _mm_fnmsub_pd(a, b, c), _mm_setzero_pd()) }
5155}
5156
5157#[inline]
5161#[target_feature(enable = "avx512f,avx512vl")]
5162#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5163#[cfg_attr(test, assert_instr(vfnmsub))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
5165pub const fn _mm_mask3_fnmsub_pd(a: __m128d, b: __m128d, c: __m128d, k: __mmask8) -> __m128d {
5166 unsafe { simd_select_bitmask(k, _mm_fnmsub_pd(a, b, c), c) }
5167}
5168
5169#[inline]
5173#[target_feature(enable = "avx512f")]
5174#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5175#[cfg_attr(test, assert_instr(vrcp14ps))]
5176pub fn _mm512_rcp14_ps(a: __m512) -> __m512 {
5177 unsafe { transmute(vrcp14ps(a.as_f32x16(), f32x16::ZERO, 0b11111111_11111111)) }
5178}
5179
5180#[inline]
5184#[target_feature(enable = "avx512f")]
5185#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5186#[cfg_attr(test, assert_instr(vrcp14ps))]
5187pub fn _mm512_mask_rcp14_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
5188 unsafe { transmute(vrcp14ps(a.as_f32x16(), src.as_f32x16(), k)) }
5189}
5190
5191#[inline]
5195#[target_feature(enable = "avx512f")]
5196#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5197#[cfg_attr(test, assert_instr(vrcp14ps))]
5198pub fn _mm512_maskz_rcp14_ps(k: __mmask16, a: __m512) -> __m512 {
5199 unsafe { transmute(vrcp14ps(a.as_f32x16(), f32x16::ZERO, k)) }
5200}
5201
5202#[inline]
5206#[target_feature(enable = "avx512f,avx512vl")]
5207#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5208#[cfg_attr(test, assert_instr(vrcp14ps))]
5209pub fn _mm256_rcp14_ps(a: __m256) -> __m256 {
5210 unsafe { transmute(vrcp14ps256(a.as_f32x8(), f32x8::ZERO, 0b11111111)) }
5211}
5212
5213#[inline]
5217#[target_feature(enable = "avx512f,avx512vl")]
5218#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5219#[cfg_attr(test, assert_instr(vrcp14ps))]
5220pub fn _mm256_mask_rcp14_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
5221 unsafe { transmute(vrcp14ps256(a.as_f32x8(), src.as_f32x8(), k)) }
5222}
5223
5224#[inline]
5228#[target_feature(enable = "avx512f,avx512vl")]
5229#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5230#[cfg_attr(test, assert_instr(vrcp14ps))]
5231pub fn _mm256_maskz_rcp14_ps(k: __mmask8, a: __m256) -> __m256 {
5232 unsafe { transmute(vrcp14ps256(a.as_f32x8(), f32x8::ZERO, k)) }
5233}
5234
5235#[inline]
5239#[target_feature(enable = "avx512f,avx512vl")]
5240#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5241#[cfg_attr(test, assert_instr(vrcp14ps))]
5242pub fn _mm_rcp14_ps(a: __m128) -> __m128 {
5243 unsafe { transmute(vrcp14ps128(a.as_f32x4(), f32x4::ZERO, 0b00001111)) }
5244}
5245
5246#[inline]
5250#[target_feature(enable = "avx512f,avx512vl")]
5251#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5252#[cfg_attr(test, assert_instr(vrcp14ps))]
5253pub fn _mm_mask_rcp14_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
5254 unsafe { transmute(vrcp14ps128(a.as_f32x4(), src.as_f32x4(), k)) }
5255}
5256
5257#[inline]
5261#[target_feature(enable = "avx512f,avx512vl")]
5262#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5263#[cfg_attr(test, assert_instr(vrcp14ps))]
5264pub fn _mm_maskz_rcp14_ps(k: __mmask8, a: __m128) -> __m128 {
5265 unsafe { transmute(vrcp14ps128(a.as_f32x4(), f32x4::ZERO, k)) }
5266}
5267
5268#[inline]
5272#[target_feature(enable = "avx512f")]
5273#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5274#[cfg_attr(test, assert_instr(vrcp14pd))]
5275pub fn _mm512_rcp14_pd(a: __m512d) -> __m512d {
5276 unsafe { transmute(vrcp14pd(a.as_f64x8(), f64x8::ZERO, 0b11111111)) }
5277}
5278
5279#[inline]
5283#[target_feature(enable = "avx512f")]
5284#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5285#[cfg_attr(test, assert_instr(vrcp14pd))]
5286pub fn _mm512_mask_rcp14_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
5287 unsafe { transmute(vrcp14pd(a.as_f64x8(), src.as_f64x8(), k)) }
5288}
5289
5290#[inline]
5294#[target_feature(enable = "avx512f")]
5295#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5296#[cfg_attr(test, assert_instr(vrcp14pd))]
5297pub fn _mm512_maskz_rcp14_pd(k: __mmask8, a: __m512d) -> __m512d {
5298 unsafe { transmute(vrcp14pd(a.as_f64x8(), f64x8::ZERO, k)) }
5299}
5300
5301#[inline]
5305#[target_feature(enable = "avx512f,avx512vl")]
5306#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5307#[cfg_attr(test, assert_instr(vrcp14pd))]
5308pub fn _mm256_rcp14_pd(a: __m256d) -> __m256d {
5309 unsafe { transmute(vrcp14pd256(a.as_f64x4(), f64x4::ZERO, 0b00001111)) }
5310}
5311
5312#[inline]
5316#[target_feature(enable = "avx512f,avx512vl")]
5317#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5318#[cfg_attr(test, assert_instr(vrcp14pd))]
5319pub fn _mm256_mask_rcp14_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
5320 unsafe { transmute(vrcp14pd256(a.as_f64x4(), src.as_f64x4(), k)) }
5321}
5322
5323#[inline]
5327#[target_feature(enable = "avx512f,avx512vl")]
5328#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5329#[cfg_attr(test, assert_instr(vrcp14pd))]
5330pub fn _mm256_maskz_rcp14_pd(k: __mmask8, a: __m256d) -> __m256d {
5331 unsafe { transmute(vrcp14pd256(a.as_f64x4(), f64x4::ZERO, k)) }
5332}
5333
5334#[inline]
5338#[target_feature(enable = "avx512f,avx512vl")]
5339#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5340#[cfg_attr(test, assert_instr(vrcp14pd))]
5341pub fn _mm_rcp14_pd(a: __m128d) -> __m128d {
5342 unsafe { transmute(vrcp14pd128(a.as_f64x2(), f64x2::ZERO, 0b00000011)) }
5343}
5344
5345#[inline]
5349#[target_feature(enable = "avx512f,avx512vl")]
5350#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5351#[cfg_attr(test, assert_instr(vrcp14pd))]
5352pub fn _mm_mask_rcp14_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
5353 unsafe { transmute(vrcp14pd128(a.as_f64x2(), src.as_f64x2(), k)) }
5354}
5355
5356#[inline]
5360#[target_feature(enable = "avx512f,avx512vl")]
5361#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5362#[cfg_attr(test, assert_instr(vrcp14pd))]
5363pub fn _mm_maskz_rcp14_pd(k: __mmask8, a: __m128d) -> __m128d {
5364 unsafe { transmute(vrcp14pd128(a.as_f64x2(), f64x2::ZERO, k)) }
5365}
5366
5367#[inline]
5371#[target_feature(enable = "avx512f")]
5372#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5373#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5374pub fn _mm512_rsqrt14_ps(a: __m512) -> __m512 {
5375 unsafe { transmute(vrsqrt14ps(a.as_f32x16(), f32x16::ZERO, 0b11111111_11111111)) }
5376}
5377
5378#[inline]
5382#[target_feature(enable = "avx512f")]
5383#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5384#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5385pub fn _mm512_mask_rsqrt14_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
5386 unsafe { transmute(vrsqrt14ps(a.as_f32x16(), src.as_f32x16(), k)) }
5387}
5388
5389#[inline]
5393#[target_feature(enable = "avx512f")]
5394#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5395#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5396pub fn _mm512_maskz_rsqrt14_ps(k: __mmask16, a: __m512) -> __m512 {
5397 unsafe { transmute(vrsqrt14ps(a.as_f32x16(), f32x16::ZERO, k)) }
5398}
5399
5400#[inline]
5404#[target_feature(enable = "avx512f,avx512vl")]
5405#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5406#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5407pub fn _mm256_rsqrt14_ps(a: __m256) -> __m256 {
5408 unsafe { transmute(vrsqrt14ps256(a.as_f32x8(), f32x8::ZERO, 0b11111111)) }
5409}
5410
5411#[inline]
5415#[target_feature(enable = "avx512f,avx512vl")]
5416#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5417#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5418pub fn _mm256_mask_rsqrt14_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
5419 unsafe { transmute(vrsqrt14ps256(a.as_f32x8(), src.as_f32x8(), k)) }
5420}
5421
5422#[inline]
5426#[target_feature(enable = "avx512f,avx512vl")]
5427#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5428#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5429pub fn _mm256_maskz_rsqrt14_ps(k: __mmask8, a: __m256) -> __m256 {
5430 unsafe { transmute(vrsqrt14ps256(a.as_f32x8(), f32x8::ZERO, k)) }
5431}
5432
5433#[inline]
5437#[target_feature(enable = "avx512f,avx512vl")]
5438#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5439#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5440pub fn _mm_rsqrt14_ps(a: __m128) -> __m128 {
5441 unsafe { transmute(vrsqrt14ps128(a.as_f32x4(), f32x4::ZERO, 0b00001111)) }
5442}
5443
5444#[inline]
5448#[target_feature(enable = "avx512f,avx512vl")]
5449#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5450#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5451pub fn _mm_mask_rsqrt14_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
5452 unsafe { transmute(vrsqrt14ps128(a.as_f32x4(), src.as_f32x4(), k)) }
5453}
5454
5455#[inline]
5459#[target_feature(enable = "avx512f,avx512vl")]
5460#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5461#[cfg_attr(test, assert_instr(vrsqrt14ps))]
5462pub fn _mm_maskz_rsqrt14_ps(k: __mmask8, a: __m128) -> __m128 {
5463 unsafe { transmute(vrsqrt14ps128(a.as_f32x4(), f32x4::ZERO, k)) }
5464}
5465
5466#[inline]
5470#[target_feature(enable = "avx512f")]
5471#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5472#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5473pub fn _mm512_rsqrt14_pd(a: __m512d) -> __m512d {
5474 unsafe { transmute(vrsqrt14pd(a.as_f64x8(), f64x8::ZERO, 0b11111111)) }
5475}
5476
5477#[inline]
5481#[target_feature(enable = "avx512f")]
5482#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5483#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5484pub fn _mm512_mask_rsqrt14_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
5485 unsafe { transmute(vrsqrt14pd(a.as_f64x8(), src.as_f64x8(), k)) }
5486}
5487
5488#[inline]
5492#[target_feature(enable = "avx512f")]
5493#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5494#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5495pub fn _mm512_maskz_rsqrt14_pd(k: __mmask8, a: __m512d) -> __m512d {
5496 unsafe { transmute(vrsqrt14pd(a.as_f64x8(), f64x8::ZERO, k)) }
5497}
5498
5499#[inline]
5503#[target_feature(enable = "avx512f,avx512vl")]
5504#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5505#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5506pub fn _mm256_rsqrt14_pd(a: __m256d) -> __m256d {
5507 unsafe { transmute(vrsqrt14pd256(a.as_f64x4(), f64x4::ZERO, 0b00001111)) }
5508}
5509
5510#[inline]
5514#[target_feature(enable = "avx512f,avx512vl")]
5515#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5516#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5517pub fn _mm256_mask_rsqrt14_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
5518 unsafe { transmute(vrsqrt14pd256(a.as_f64x4(), src.as_f64x4(), k)) }
5519}
5520
5521#[inline]
5525#[target_feature(enable = "avx512f,avx512vl")]
5526#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5527#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5528pub fn _mm256_maskz_rsqrt14_pd(k: __mmask8, a: __m256d) -> __m256d {
5529 unsafe { transmute(vrsqrt14pd256(a.as_f64x4(), f64x4::ZERO, k)) }
5530}
5531
5532#[inline]
5536#[target_feature(enable = "avx512f,avx512vl")]
5537#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5538#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5539pub fn _mm_rsqrt14_pd(a: __m128d) -> __m128d {
5540 unsafe { transmute(vrsqrt14pd128(a.as_f64x2(), f64x2::ZERO, 0b00000011)) }
5541}
5542
5543#[inline]
5547#[target_feature(enable = "avx512f,avx512vl")]
5548#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5549#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5550pub fn _mm_mask_rsqrt14_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
5551 unsafe { transmute(vrsqrt14pd128(a.as_f64x2(), src.as_f64x2(), k)) }
5552}
5553
5554#[inline]
5558#[target_feature(enable = "avx512f,avx512vl")]
5559#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5560#[cfg_attr(test, assert_instr(vrsqrt14pd))]
5561pub fn _mm_maskz_rsqrt14_pd(k: __mmask8, a: __m128d) -> __m128d {
5562 unsafe { transmute(vrsqrt14pd128(a.as_f64x2(), f64x2::ZERO, k)) }
5563}
5564
5565#[inline]
5569#[target_feature(enable = "avx512f")]
5570#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5571#[cfg_attr(test, assert_instr(vgetexpps))]
5572pub fn _mm512_getexp_ps(a: __m512) -> __m512 {
5573 unsafe {
5574 transmute(vgetexpps(
5575 a.as_f32x16(),
5576 f32x16::ZERO,
5577 0b11111111_11111111,
5578 _MM_FROUND_CUR_DIRECTION,
5579 ))
5580 }
5581}
5582
5583#[inline]
5587#[target_feature(enable = "avx512f")]
5588#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5589#[cfg_attr(test, assert_instr(vgetexpps))]
5590pub fn _mm512_mask_getexp_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
5591 unsafe {
5592 transmute(vgetexpps(
5593 a.as_f32x16(),
5594 src.as_f32x16(),
5595 k,
5596 _MM_FROUND_CUR_DIRECTION,
5597 ))
5598 }
5599}
5600
5601#[inline]
5605#[target_feature(enable = "avx512f")]
5606#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5607#[cfg_attr(test, assert_instr(vgetexpps))]
5608pub fn _mm512_maskz_getexp_ps(k: __mmask16, a: __m512) -> __m512 {
5609 unsafe {
5610 transmute(vgetexpps(
5611 a.as_f32x16(),
5612 f32x16::ZERO,
5613 k,
5614 _MM_FROUND_CUR_DIRECTION,
5615 ))
5616 }
5617}
5618
5619#[inline]
5623#[target_feature(enable = "avx512f,avx512vl")]
5624#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5625#[cfg_attr(test, assert_instr(vgetexpps))]
5626pub fn _mm256_getexp_ps(a: __m256) -> __m256 {
5627 unsafe { transmute(vgetexpps256(a.as_f32x8(), f32x8::ZERO, 0b11111111)) }
5628}
5629
5630#[inline]
5634#[target_feature(enable = "avx512f,avx512vl")]
5635#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5636#[cfg_attr(test, assert_instr(vgetexpps))]
5637pub fn _mm256_mask_getexp_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
5638 unsafe { transmute(vgetexpps256(a.as_f32x8(), src.as_f32x8(), k)) }
5639}
5640
5641#[inline]
5645#[target_feature(enable = "avx512f,avx512vl")]
5646#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5647#[cfg_attr(test, assert_instr(vgetexpps))]
5648pub fn _mm256_maskz_getexp_ps(k: __mmask8, a: __m256) -> __m256 {
5649 unsafe { transmute(vgetexpps256(a.as_f32x8(), f32x8::ZERO, k)) }
5650}
5651
5652#[inline]
5656#[target_feature(enable = "avx512f,avx512vl")]
5657#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5658#[cfg_attr(test, assert_instr(vgetexpps))]
5659pub fn _mm_getexp_ps(a: __m128) -> __m128 {
5660 unsafe { transmute(vgetexpps128(a.as_f32x4(), f32x4::ZERO, 0b00001111)) }
5661}
5662
5663#[inline]
5667#[target_feature(enable = "avx512f,avx512vl")]
5668#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5669#[cfg_attr(test, assert_instr(vgetexpps))]
5670pub fn _mm_mask_getexp_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
5671 unsafe { transmute(vgetexpps128(a.as_f32x4(), src.as_f32x4(), k)) }
5672}
5673
5674#[inline]
5678#[target_feature(enable = "avx512f,avx512vl")]
5679#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5680#[cfg_attr(test, assert_instr(vgetexpps))]
5681pub fn _mm_maskz_getexp_ps(k: __mmask8, a: __m128) -> __m128 {
5682 unsafe { transmute(vgetexpps128(a.as_f32x4(), f32x4::ZERO, k)) }
5683}
5684
5685#[inline]
5689#[target_feature(enable = "avx512f")]
5690#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5691#[cfg_attr(test, assert_instr(vgetexppd))]
5692pub fn _mm512_getexp_pd(a: __m512d) -> __m512d {
5693 unsafe {
5694 transmute(vgetexppd(
5695 a.as_f64x8(),
5696 f64x8::ZERO,
5697 0b11111111,
5698 _MM_FROUND_CUR_DIRECTION,
5699 ))
5700 }
5701}
5702
5703#[inline]
5707#[target_feature(enable = "avx512f")]
5708#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5709#[cfg_attr(test, assert_instr(vgetexppd))]
5710pub fn _mm512_mask_getexp_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
5711 unsafe {
5712 transmute(vgetexppd(
5713 a.as_f64x8(),
5714 src.as_f64x8(),
5715 k,
5716 _MM_FROUND_CUR_DIRECTION,
5717 ))
5718 }
5719}
5720
5721#[inline]
5725#[target_feature(enable = "avx512f")]
5726#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5727#[cfg_attr(test, assert_instr(vgetexppd))]
5728pub fn _mm512_maskz_getexp_pd(k: __mmask8, a: __m512d) -> __m512d {
5729 unsafe {
5730 transmute(vgetexppd(
5731 a.as_f64x8(),
5732 f64x8::ZERO,
5733 k,
5734 _MM_FROUND_CUR_DIRECTION,
5735 ))
5736 }
5737}
5738
5739#[inline]
5743#[target_feature(enable = "avx512f,avx512vl")]
5744#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5745#[cfg_attr(test, assert_instr(vgetexppd))]
5746pub fn _mm256_getexp_pd(a: __m256d) -> __m256d {
5747 unsafe { transmute(vgetexppd256(a.as_f64x4(), f64x4::ZERO, 0b00001111)) }
5748}
5749
5750#[inline]
5754#[target_feature(enable = "avx512f,avx512vl")]
5755#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5756#[cfg_attr(test, assert_instr(vgetexppd))]
5757pub fn _mm256_mask_getexp_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
5758 unsafe { transmute(vgetexppd256(a.as_f64x4(), src.as_f64x4(), k)) }
5759}
5760
5761#[inline]
5765#[target_feature(enable = "avx512f,avx512vl")]
5766#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5767#[cfg_attr(test, assert_instr(vgetexppd))]
5768pub fn _mm256_maskz_getexp_pd(k: __mmask8, a: __m256d) -> __m256d {
5769 unsafe { transmute(vgetexppd256(a.as_f64x4(), f64x4::ZERO, k)) }
5770}
5771
5772#[inline]
5776#[target_feature(enable = "avx512f,avx512vl")]
5777#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5778#[cfg_attr(test, assert_instr(vgetexppd))]
5779pub fn _mm_getexp_pd(a: __m128d) -> __m128d {
5780 unsafe { transmute(vgetexppd128(a.as_f64x2(), f64x2::ZERO, 0b00000011)) }
5781}
5782
5783#[inline]
5787#[target_feature(enable = "avx512f,avx512vl")]
5788#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5789#[cfg_attr(test, assert_instr(vgetexppd))]
5790pub fn _mm_mask_getexp_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
5791 unsafe { transmute(vgetexppd128(a.as_f64x2(), src.as_f64x2(), k)) }
5792}
5793
5794#[inline]
5798#[target_feature(enable = "avx512f,avx512vl")]
5799#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5800#[cfg_attr(test, assert_instr(vgetexppd))]
5801pub fn _mm_maskz_getexp_pd(k: __mmask8, a: __m128d) -> __m128d {
5802 unsafe { transmute(vgetexppd128(a.as_f64x2(), f64x2::ZERO, k)) }
5803}
5804
5805#[inline]
5815#[target_feature(enable = "avx512f")]
5816#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5817#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0))]
5818#[rustc_legacy_const_generics(1)]
5819pub fn _mm512_roundscale_ps<const IMM8: i32>(a: __m512) -> __m512 {
5820 unsafe {
5821 static_assert_uimm_bits!(IMM8, 8);
5822 let a = a.as_f32x16();
5823 let r = vrndscaleps(
5824 a,
5825 IMM8,
5826 f32x16::ZERO,
5827 0b11111111_11111111,
5828 _MM_FROUND_CUR_DIRECTION,
5829 );
5830 transmute(r)
5831 }
5832}
5833
5834#[inline]
5844#[target_feature(enable = "avx512f")]
5845#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5846#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0))]
5847#[rustc_legacy_const_generics(3)]
5848pub fn _mm512_mask_roundscale_ps<const IMM8: i32>(src: __m512, k: __mmask16, a: __m512) -> __m512 {
5849 unsafe {
5850 static_assert_uimm_bits!(IMM8, 8);
5851 let a = a.as_f32x16();
5852 let src = src.as_f32x16();
5853 let r = vrndscaleps(a, IMM8, src, k, _MM_FROUND_CUR_DIRECTION);
5854 transmute(r)
5855 }
5856}
5857
5858#[inline]
5868#[target_feature(enable = "avx512f")]
5869#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5870#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0))]
5871#[rustc_legacy_const_generics(2)]
5872pub fn _mm512_maskz_roundscale_ps<const IMM8: i32>(k: __mmask16, a: __m512) -> __m512 {
5873 unsafe {
5874 static_assert_uimm_bits!(IMM8, 8);
5875 let a = a.as_f32x16();
5876 let r = vrndscaleps(a, IMM8, f32x16::ZERO, k, _MM_FROUND_CUR_DIRECTION);
5877 transmute(r)
5878 }
5879}
5880
5881#[inline]
5891#[target_feature(enable = "avx512f,avx512vl")]
5892#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5893#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 250))]
5894#[rustc_legacy_const_generics(1)]
5895pub fn _mm256_roundscale_ps<const IMM8: i32>(a: __m256) -> __m256 {
5896 unsafe {
5897 static_assert_uimm_bits!(IMM8, 8);
5898 let a = a.as_f32x8();
5899 let r = vrndscaleps256(a, IMM8, f32x8::ZERO, 0b11111111);
5900 transmute(r)
5901 }
5902}
5903
5904#[inline]
5914#[target_feature(enable = "avx512f,avx512vl")]
5915#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5916#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0))]
5917#[rustc_legacy_const_generics(3)]
5918pub fn _mm256_mask_roundscale_ps<const IMM8: i32>(src: __m256, k: __mmask8, a: __m256) -> __m256 {
5919 unsafe {
5920 static_assert_uimm_bits!(IMM8, 8);
5921 let a = a.as_f32x8();
5922 let src = src.as_f32x8();
5923 let r = vrndscaleps256(a, IMM8, src, k);
5924 transmute(r)
5925 }
5926}
5927
5928#[inline]
5938#[target_feature(enable = "avx512f,avx512vl")]
5939#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5940#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0))]
5941#[rustc_legacy_const_generics(2)]
5942pub fn _mm256_maskz_roundscale_ps<const IMM8: i32>(k: __mmask8, a: __m256) -> __m256 {
5943 unsafe {
5944 static_assert_uimm_bits!(IMM8, 8);
5945 let a = a.as_f32x8();
5946 let r = vrndscaleps256(a, IMM8, f32x8::ZERO, k);
5947 transmute(r)
5948 }
5949}
5950
5951#[inline]
5961#[target_feature(enable = "avx512f,avx512vl")]
5962#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5963#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 250))]
5964#[rustc_legacy_const_generics(1)]
5965pub fn _mm_roundscale_ps<const IMM8: i32>(a: __m128) -> __m128 {
5966 unsafe {
5967 static_assert_uimm_bits!(IMM8, 8);
5968 let a = a.as_f32x4();
5969 let r = vrndscaleps128(a, IMM8, f32x4::ZERO, 0b00001111);
5970 transmute(r)
5971 }
5972}
5973
5974#[inline]
5984#[target_feature(enable = "avx512f,avx512vl")]
5985#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
5986#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0))]
5987#[rustc_legacy_const_generics(3)]
5988pub fn _mm_mask_roundscale_ps<const IMM8: i32>(src: __m128, k: __mmask8, a: __m128) -> __m128 {
5989 unsafe {
5990 static_assert_uimm_bits!(IMM8, 8);
5991 let a = a.as_f32x4();
5992 let src = src.as_f32x4();
5993 let r = vrndscaleps128(a, IMM8, src, k);
5994 transmute(r)
5995 }
5996}
5997
5998#[inline]
6008#[target_feature(enable = "avx512f,avx512vl")]
6009#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6010#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0))]
6011#[rustc_legacy_const_generics(2)]
6012pub fn _mm_maskz_roundscale_ps<const IMM8: i32>(k: __mmask8, a: __m128) -> __m128 {
6013 unsafe {
6014 static_assert_uimm_bits!(IMM8, 8);
6015 let a = a.as_f32x4();
6016 let r = vrndscaleps128(a, IMM8, f32x4::ZERO, k);
6017 transmute(r)
6018 }
6019}
6020
6021#[inline]
6031#[target_feature(enable = "avx512f")]
6032#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6033#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
6034#[rustc_legacy_const_generics(1)]
6035pub fn _mm512_roundscale_pd<const IMM8: i32>(a: __m512d) -> __m512d {
6036 unsafe {
6037 static_assert_uimm_bits!(IMM8, 8);
6038 let a = a.as_f64x8();
6039 let r = vrndscalepd(a, IMM8, f64x8::ZERO, 0b11111111, _MM_FROUND_CUR_DIRECTION);
6040 transmute(r)
6041 }
6042}
6043
6044#[inline]
6054#[target_feature(enable = "avx512f")]
6055#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6056#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
6057#[rustc_legacy_const_generics(3)]
6058pub fn _mm512_mask_roundscale_pd<const IMM8: i32>(
6059 src: __m512d,
6060 k: __mmask8,
6061 a: __m512d,
6062) -> __m512d {
6063 unsafe {
6064 static_assert_uimm_bits!(IMM8, 8);
6065 let a = a.as_f64x8();
6066 let src = src.as_f64x8();
6067 let r = vrndscalepd(a, IMM8, src, k, _MM_FROUND_CUR_DIRECTION);
6068 transmute(r)
6069 }
6070}
6071
6072#[inline]
6082#[target_feature(enable = "avx512f")]
6083#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6084#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
6085#[rustc_legacy_const_generics(2)]
6086pub fn _mm512_maskz_roundscale_pd<const IMM8: i32>(k: __mmask8, a: __m512d) -> __m512d {
6087 unsafe {
6088 static_assert_uimm_bits!(IMM8, 8);
6089 let a = a.as_f64x8();
6090 let r = vrndscalepd(a, IMM8, f64x8::ZERO, k, _MM_FROUND_CUR_DIRECTION);
6091 transmute(r)
6092 }
6093}
6094
6095#[inline]
6105#[target_feature(enable = "avx512f,avx512vl")]
6106#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6107#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 16))]
6108#[rustc_legacy_const_generics(1)]
6109pub fn _mm256_roundscale_pd<const IMM8: i32>(a: __m256d) -> __m256d {
6110 unsafe {
6111 static_assert_uimm_bits!(IMM8, 8);
6112 let a = a.as_f64x4();
6113 let r = vrndscalepd256(a, IMM8, f64x4::ZERO, 0b00001111);
6114 transmute(r)
6115 }
6116}
6117
6118#[inline]
6128#[target_feature(enable = "avx512f,avx512vl")]
6129#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6130#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
6131#[rustc_legacy_const_generics(3)]
6132pub fn _mm256_mask_roundscale_pd<const IMM8: i32>(
6133 src: __m256d,
6134 k: __mmask8,
6135 a: __m256d,
6136) -> __m256d {
6137 unsafe {
6138 static_assert_uimm_bits!(IMM8, 8);
6139 let a = a.as_f64x4();
6140 let src = src.as_f64x4();
6141 let r = vrndscalepd256(a, IMM8, src, k);
6142 transmute(r)
6143 }
6144}
6145
6146#[inline]
6156#[target_feature(enable = "avx512f,avx512vl")]
6157#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6158#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
6159#[rustc_legacy_const_generics(2)]
6160pub fn _mm256_maskz_roundscale_pd<const IMM8: i32>(k: __mmask8, a: __m256d) -> __m256d {
6161 unsafe {
6162 static_assert_uimm_bits!(IMM8, 8);
6163 let a = a.as_f64x4();
6164 let r = vrndscalepd256(a, IMM8, f64x4::ZERO, k);
6165 transmute(r)
6166 }
6167}
6168
6169#[inline]
6179#[target_feature(enable = "avx512f,avx512vl")]
6180#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6181#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 16))]
6182#[rustc_legacy_const_generics(1)]
6183pub fn _mm_roundscale_pd<const IMM8: i32>(a: __m128d) -> __m128d {
6184 unsafe {
6185 static_assert_uimm_bits!(IMM8, 8);
6186 let a = a.as_f64x2();
6187 let r = vrndscalepd128(a, IMM8, f64x2::ZERO, 0b00000011);
6188 transmute(r)
6189 }
6190}
6191
6192#[inline]
6202#[target_feature(enable = "avx512f,avx512vl")]
6203#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6204#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
6205#[rustc_legacy_const_generics(3)]
6206pub fn _mm_mask_roundscale_pd<const IMM8: i32>(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
6207 unsafe {
6208 static_assert_uimm_bits!(IMM8, 8);
6209 let a = a.as_f64x2();
6210 let src = src.as_f64x2();
6211 let r = vrndscalepd128(a, IMM8, src, k);
6212 transmute(r)
6213 }
6214}
6215
6216#[inline]
6226#[target_feature(enable = "avx512f,avx512vl")]
6227#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6228#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0))]
6229#[rustc_legacy_const_generics(2)]
6230pub fn _mm_maskz_roundscale_pd<const IMM8: i32>(k: __mmask8, a: __m128d) -> __m128d {
6231 unsafe {
6232 static_assert_uimm_bits!(IMM8, 8);
6233 let a = a.as_f64x2();
6234 let r = vrndscalepd128(a, IMM8, f64x2::ZERO, k);
6235 transmute(r)
6236 }
6237}
6238
6239#[inline]
6243#[target_feature(enable = "avx512f")]
6244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6245#[cfg_attr(test, assert_instr(vscalefps))]
6246pub fn _mm512_scalef_ps(a: __m512, b: __m512) -> __m512 {
6247 unsafe {
6248 transmute(vscalefps(
6249 a.as_f32x16(),
6250 b.as_f32x16(),
6251 f32x16::ZERO,
6252 0b11111111_11111111,
6253 _MM_FROUND_CUR_DIRECTION,
6254 ))
6255 }
6256}
6257
6258#[inline]
6262#[target_feature(enable = "avx512f")]
6263#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6264#[cfg_attr(test, assert_instr(vscalefps))]
6265pub fn _mm512_mask_scalef_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
6266 unsafe {
6267 transmute(vscalefps(
6268 a.as_f32x16(),
6269 b.as_f32x16(),
6270 src.as_f32x16(),
6271 k,
6272 _MM_FROUND_CUR_DIRECTION,
6273 ))
6274 }
6275}
6276
6277#[inline]
6281#[target_feature(enable = "avx512f")]
6282#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6283#[cfg_attr(test, assert_instr(vscalefps))]
6284pub fn _mm512_maskz_scalef_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
6285 unsafe {
6286 transmute(vscalefps(
6287 a.as_f32x16(),
6288 b.as_f32x16(),
6289 f32x16::ZERO,
6290 k,
6291 _MM_FROUND_CUR_DIRECTION,
6292 ))
6293 }
6294}
6295
6296#[inline]
6300#[target_feature(enable = "avx512f,avx512vl")]
6301#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6302#[cfg_attr(test, assert_instr(vscalefps))]
6303pub fn _mm256_scalef_ps(a: __m256, b: __m256) -> __m256 {
6304 unsafe {
6305 transmute(vscalefps256(
6306 a.as_f32x8(),
6307 b.as_f32x8(),
6308 f32x8::ZERO,
6309 0b11111111,
6310 ))
6311 }
6312}
6313
6314#[inline]
6318#[target_feature(enable = "avx512f,avx512vl")]
6319#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6320#[cfg_attr(test, assert_instr(vscalefps))]
6321pub fn _mm256_mask_scalef_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
6322 unsafe { transmute(vscalefps256(a.as_f32x8(), b.as_f32x8(), src.as_f32x8(), k)) }
6323}
6324
6325#[inline]
6329#[target_feature(enable = "avx512f,avx512vl")]
6330#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6331#[cfg_attr(test, assert_instr(vscalefps))]
6332pub fn _mm256_maskz_scalef_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
6333 unsafe { transmute(vscalefps256(a.as_f32x8(), b.as_f32x8(), f32x8::ZERO, k)) }
6334}
6335
6336#[inline]
6340#[target_feature(enable = "avx512f,avx512vl")]
6341#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6342#[cfg_attr(test, assert_instr(vscalefps))]
6343pub fn _mm_scalef_ps(a: __m128, b: __m128) -> __m128 {
6344 unsafe {
6345 transmute(vscalefps128(
6346 a.as_f32x4(),
6347 b.as_f32x4(),
6348 f32x4::ZERO,
6349 0b00001111,
6350 ))
6351 }
6352}
6353
6354#[inline]
6358#[target_feature(enable = "avx512f,avx512vl")]
6359#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6360#[cfg_attr(test, assert_instr(vscalefps))]
6361pub fn _mm_mask_scalef_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
6362 unsafe { transmute(vscalefps128(a.as_f32x4(), b.as_f32x4(), src.as_f32x4(), k)) }
6363}
6364
6365#[inline]
6369#[target_feature(enable = "avx512f,avx512vl")]
6370#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6371#[cfg_attr(test, assert_instr(vscalefps))]
6372pub fn _mm_maskz_scalef_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
6373 unsafe { transmute(vscalefps128(a.as_f32x4(), b.as_f32x4(), f32x4::ZERO, k)) }
6374}
6375
6376#[inline]
6380#[target_feature(enable = "avx512f")]
6381#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6382#[cfg_attr(test, assert_instr(vscalefpd))]
6383pub fn _mm512_scalef_pd(a: __m512d, b: __m512d) -> __m512d {
6384 unsafe {
6385 transmute(vscalefpd(
6386 a.as_f64x8(),
6387 b.as_f64x8(),
6388 f64x8::ZERO,
6389 0b11111111,
6390 _MM_FROUND_CUR_DIRECTION,
6391 ))
6392 }
6393}
6394
6395#[inline]
6399#[target_feature(enable = "avx512f")]
6400#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6401#[cfg_attr(test, assert_instr(vscalefpd))]
6402pub fn _mm512_mask_scalef_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
6403 unsafe {
6404 transmute(vscalefpd(
6405 a.as_f64x8(),
6406 b.as_f64x8(),
6407 src.as_f64x8(),
6408 k,
6409 _MM_FROUND_CUR_DIRECTION,
6410 ))
6411 }
6412}
6413
6414#[inline]
6418#[target_feature(enable = "avx512f")]
6419#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6420#[cfg_attr(test, assert_instr(vscalefpd))]
6421pub fn _mm512_maskz_scalef_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
6422 unsafe {
6423 transmute(vscalefpd(
6424 a.as_f64x8(),
6425 b.as_f64x8(),
6426 f64x8::ZERO,
6427 k,
6428 _MM_FROUND_CUR_DIRECTION,
6429 ))
6430 }
6431}
6432
6433#[inline]
6437#[target_feature(enable = "avx512f,avx512vl")]
6438#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6439#[cfg_attr(test, assert_instr(vscalefpd))]
6440pub fn _mm256_scalef_pd(a: __m256d, b: __m256d) -> __m256d {
6441 unsafe {
6442 transmute(vscalefpd256(
6443 a.as_f64x4(),
6444 b.as_f64x4(),
6445 f64x4::ZERO,
6446 0b00001111,
6447 ))
6448 }
6449}
6450
6451#[inline]
6455#[target_feature(enable = "avx512f,avx512vl")]
6456#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6457#[cfg_attr(test, assert_instr(vscalefpd))]
6458pub fn _mm256_mask_scalef_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
6459 unsafe { transmute(vscalefpd256(a.as_f64x4(), b.as_f64x4(), src.as_f64x4(), k)) }
6460}
6461
6462#[inline]
6466#[target_feature(enable = "avx512f,avx512vl")]
6467#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6468#[cfg_attr(test, assert_instr(vscalefpd))]
6469pub fn _mm256_maskz_scalef_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
6470 unsafe { transmute(vscalefpd256(a.as_f64x4(), b.as_f64x4(), f64x4::ZERO, k)) }
6471}
6472
6473#[inline]
6477#[target_feature(enable = "avx512f,avx512vl")]
6478#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6479#[cfg_attr(test, assert_instr(vscalefpd))]
6480pub fn _mm_scalef_pd(a: __m128d, b: __m128d) -> __m128d {
6481 unsafe {
6482 transmute(vscalefpd128(
6483 a.as_f64x2(),
6484 b.as_f64x2(),
6485 f64x2::ZERO,
6486 0b00000011,
6487 ))
6488 }
6489}
6490
6491#[inline]
6495#[target_feature(enable = "avx512f,avx512vl")]
6496#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6497#[cfg_attr(test, assert_instr(vscalefpd))]
6498pub fn _mm_mask_scalef_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
6499 unsafe { transmute(vscalefpd128(a.as_f64x2(), b.as_f64x2(), src.as_f64x2(), k)) }
6500}
6501
6502#[inline]
6506#[target_feature(enable = "avx512f,avx512vl")]
6507#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6508#[cfg_attr(test, assert_instr(vscalefpd))]
6509pub fn _mm_maskz_scalef_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
6510 unsafe { transmute(vscalefpd128(a.as_f64x2(), b.as_f64x2(), f64x2::ZERO, k)) }
6511}
6512
6513#[inline]
6517#[target_feature(enable = "avx512f")]
6518#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6519#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6520#[rustc_legacy_const_generics(3)]
6521pub fn _mm512_fixupimm_ps<const IMM8: i32>(a: __m512, b: __m512, c: __m512i) -> __m512 {
6522 unsafe {
6523 static_assert_uimm_bits!(IMM8, 8);
6524 let a = a.as_f32x16();
6525 let b = b.as_f32x16();
6526 let c = c.as_i32x16();
6527 let r = vfixupimmps(a, b, c, IMM8, 0b11111111_11111111, _MM_FROUND_CUR_DIRECTION);
6528 transmute(r)
6529 }
6530}
6531
6532#[inline]
6536#[target_feature(enable = "avx512f")]
6537#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6538#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6539#[rustc_legacy_const_generics(4)]
6540pub fn _mm512_mask_fixupimm_ps<const IMM8: i32>(
6541 a: __m512,
6542 k: __mmask16,
6543 b: __m512,
6544 c: __m512i,
6545) -> __m512 {
6546 unsafe {
6547 static_assert_uimm_bits!(IMM8, 8);
6548 let a = a.as_f32x16();
6549 let b = b.as_f32x16();
6550 let c = c.as_i32x16();
6551 let r = vfixupimmps(a, b, c, IMM8, k, _MM_FROUND_CUR_DIRECTION);
6552 transmute(r)
6553 }
6554}
6555
6556#[inline]
6560#[target_feature(enable = "avx512f")]
6561#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6562#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6563#[rustc_legacy_const_generics(4)]
6564pub fn _mm512_maskz_fixupimm_ps<const IMM8: i32>(
6565 k: __mmask16,
6566 a: __m512,
6567 b: __m512,
6568 c: __m512i,
6569) -> __m512 {
6570 unsafe {
6571 static_assert_uimm_bits!(IMM8, 8);
6572 let a = a.as_f32x16();
6573 let b = b.as_f32x16();
6574 let c = c.as_i32x16();
6575 let r = vfixupimmpsz(a, b, c, IMM8, k, _MM_FROUND_CUR_DIRECTION);
6576 transmute(r)
6577 }
6578}
6579
6580#[inline]
6584#[target_feature(enable = "avx512f,avx512vl")]
6585#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6586#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6587#[rustc_legacy_const_generics(3)]
6588pub fn _mm256_fixupimm_ps<const IMM8: i32>(a: __m256, b: __m256, c: __m256i) -> __m256 {
6589 unsafe {
6590 static_assert_uimm_bits!(IMM8, 8);
6591 let a = a.as_f32x8();
6592 let b = b.as_f32x8();
6593 let c = c.as_i32x8();
6594 let r = vfixupimmps256(a, b, c, IMM8, 0b11111111);
6595 transmute(r)
6596 }
6597}
6598
6599#[inline]
6603#[target_feature(enable = "avx512f,avx512vl")]
6604#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6605#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6606#[rustc_legacy_const_generics(4)]
6607pub fn _mm256_mask_fixupimm_ps<const IMM8: i32>(
6608 a: __m256,
6609 k: __mmask8,
6610 b: __m256,
6611 c: __m256i,
6612) -> __m256 {
6613 unsafe {
6614 static_assert_uimm_bits!(IMM8, 8);
6615 let a = a.as_f32x8();
6616 let b = b.as_f32x8();
6617 let c = c.as_i32x8();
6618 let r = vfixupimmps256(a, b, c, IMM8, k);
6619 transmute(r)
6620 }
6621}
6622
6623#[inline]
6627#[target_feature(enable = "avx512f,avx512vl")]
6628#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6629#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6630#[rustc_legacy_const_generics(4)]
6631pub fn _mm256_maskz_fixupimm_ps<const IMM8: i32>(
6632 k: __mmask8,
6633 a: __m256,
6634 b: __m256,
6635 c: __m256i,
6636) -> __m256 {
6637 unsafe {
6638 static_assert_uimm_bits!(IMM8, 8);
6639 let a = a.as_f32x8();
6640 let b = b.as_f32x8();
6641 let c = c.as_i32x8();
6642 let r = vfixupimmpsz256(a, b, c, IMM8, k);
6643 transmute(r)
6644 }
6645}
6646
6647#[inline]
6651#[target_feature(enable = "avx512f,avx512vl")]
6652#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6653#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6654#[rustc_legacy_const_generics(3)]
6655pub fn _mm_fixupimm_ps<const IMM8: i32>(a: __m128, b: __m128, c: __m128i) -> __m128 {
6656 unsafe {
6657 static_assert_uimm_bits!(IMM8, 8);
6658 let a = a.as_f32x4();
6659 let b = b.as_f32x4();
6660 let c = c.as_i32x4();
6661 let r = vfixupimmps128(a, b, c, IMM8, 0b00001111);
6662 transmute(r)
6663 }
6664}
6665
6666#[inline]
6670#[target_feature(enable = "avx512f,avx512vl")]
6671#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6672#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6673#[rustc_legacy_const_generics(4)]
6674pub fn _mm_mask_fixupimm_ps<const IMM8: i32>(
6675 a: __m128,
6676 k: __mmask8,
6677 b: __m128,
6678 c: __m128i,
6679) -> __m128 {
6680 unsafe {
6681 static_assert_uimm_bits!(IMM8, 8);
6682 let a = a.as_f32x4();
6683 let b = b.as_f32x4();
6684 let c = c.as_i32x4();
6685 let r = vfixupimmps128(a, b, c, IMM8, k);
6686 transmute(r)
6687 }
6688}
6689
6690#[inline]
6694#[target_feature(enable = "avx512f,avx512vl")]
6695#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6696#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0))]
6697#[rustc_legacy_const_generics(4)]
6698pub fn _mm_maskz_fixupimm_ps<const IMM8: i32>(
6699 k: __mmask8,
6700 a: __m128,
6701 b: __m128,
6702 c: __m128i,
6703) -> __m128 {
6704 unsafe {
6705 static_assert_uimm_bits!(IMM8, 8);
6706 let a = a.as_f32x4();
6707 let b = b.as_f32x4();
6708 let c = c.as_i32x4();
6709 let r = vfixupimmpsz128(a, b, c, IMM8, k);
6710 transmute(r)
6711 }
6712}
6713
6714#[inline]
6718#[target_feature(enable = "avx512f")]
6719#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6720#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6721#[rustc_legacy_const_generics(3)]
6722pub fn _mm512_fixupimm_pd<const IMM8: i32>(a: __m512d, b: __m512d, c: __m512i) -> __m512d {
6723 unsafe {
6724 static_assert_uimm_bits!(IMM8, 8);
6725 let a = a.as_f64x8();
6726 let b = b.as_f64x8();
6727 let c = c.as_i64x8();
6728 let r = vfixupimmpd(a, b, c, IMM8, 0b11111111, _MM_FROUND_CUR_DIRECTION);
6729 transmute(r)
6730 }
6731}
6732
6733#[inline]
6737#[target_feature(enable = "avx512f")]
6738#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6739#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6740#[rustc_legacy_const_generics(4)]
6741pub fn _mm512_mask_fixupimm_pd<const IMM8: i32>(
6742 a: __m512d,
6743 k: __mmask8,
6744 b: __m512d,
6745 c: __m512i,
6746) -> __m512d {
6747 unsafe {
6748 static_assert_uimm_bits!(IMM8, 8);
6749 let a = a.as_f64x8();
6750 let b = b.as_f64x8();
6751 let c = c.as_i64x8();
6752 let r = vfixupimmpd(a, b, c, IMM8, k, _MM_FROUND_CUR_DIRECTION);
6753 transmute(r)
6754 }
6755}
6756
6757#[inline]
6761#[target_feature(enable = "avx512f")]
6762#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6763#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6764#[rustc_legacy_const_generics(4)]
6765pub fn _mm512_maskz_fixupimm_pd<const IMM8: i32>(
6766 k: __mmask8,
6767 a: __m512d,
6768 b: __m512d,
6769 c: __m512i,
6770) -> __m512d {
6771 unsafe {
6772 static_assert_uimm_bits!(IMM8, 8);
6773 let a = a.as_f64x8();
6774 let b = b.as_f64x8();
6775 let c = c.as_i64x8();
6776 let r = vfixupimmpdz(a, b, c, IMM8, k, _MM_FROUND_CUR_DIRECTION);
6777 transmute(r)
6778 }
6779}
6780
6781#[inline]
6785#[target_feature(enable = "avx512f,avx512vl")]
6786#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6787#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6788#[rustc_legacy_const_generics(3)]
6789pub fn _mm256_fixupimm_pd<const IMM8: i32>(a: __m256d, b: __m256d, c: __m256i) -> __m256d {
6790 unsafe {
6791 static_assert_uimm_bits!(IMM8, 8);
6792 let a = a.as_f64x4();
6793 let b = b.as_f64x4();
6794 let c = c.as_i64x4();
6795 let r = vfixupimmpd256(a, b, c, IMM8, 0b00001111);
6796 transmute(r)
6797 }
6798}
6799
6800#[inline]
6804#[target_feature(enable = "avx512f,avx512vl")]
6805#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6806#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6807#[rustc_legacy_const_generics(4)]
6808pub fn _mm256_mask_fixupimm_pd<const IMM8: i32>(
6809 a: __m256d,
6810 k: __mmask8,
6811 b: __m256d,
6812 c: __m256i,
6813) -> __m256d {
6814 unsafe {
6815 static_assert_uimm_bits!(IMM8, 8);
6816 let a = a.as_f64x4();
6817 let b = b.as_f64x4();
6818 let c = c.as_i64x4();
6819 let r = vfixupimmpd256(a, b, c, IMM8, k);
6820 transmute(r)
6821 }
6822}
6823
6824#[inline]
6828#[target_feature(enable = "avx512f,avx512vl")]
6829#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6830#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6831#[rustc_legacy_const_generics(4)]
6832pub fn _mm256_maskz_fixupimm_pd<const IMM8: i32>(
6833 k: __mmask8,
6834 a: __m256d,
6835 b: __m256d,
6836 c: __m256i,
6837) -> __m256d {
6838 unsafe {
6839 static_assert_uimm_bits!(IMM8, 8);
6840 let a = a.as_f64x4();
6841 let b = b.as_f64x4();
6842 let c = c.as_i64x4();
6843 let r = vfixupimmpdz256(a, b, c, IMM8, k);
6844 transmute(r)
6845 }
6846}
6847
6848#[inline]
6852#[target_feature(enable = "avx512f,avx512vl")]
6853#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6854#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6855#[rustc_legacy_const_generics(3)]
6856pub fn _mm_fixupimm_pd<const IMM8: i32>(a: __m128d, b: __m128d, c: __m128i) -> __m128d {
6857 unsafe {
6858 static_assert_uimm_bits!(IMM8, 8);
6859 let a = a.as_f64x2();
6860 let b = b.as_f64x2();
6861 let c = c.as_i64x2();
6862 let r = vfixupimmpd128(a, b, c, IMM8, 0b00000011);
6863 transmute(r)
6864 }
6865}
6866
6867#[inline]
6871#[target_feature(enable = "avx512f,avx512vl")]
6872#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6873#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6874#[rustc_legacy_const_generics(4)]
6875pub fn _mm_mask_fixupimm_pd<const IMM8: i32>(
6876 a: __m128d,
6877 k: __mmask8,
6878 b: __m128d,
6879 c: __m128i,
6880) -> __m128d {
6881 unsafe {
6882 static_assert_uimm_bits!(IMM8, 8);
6883 let a = a.as_f64x2();
6884 let b = b.as_f64x2();
6885 let c = c.as_i64x2();
6886 let r = vfixupimmpd128(a, b, c, IMM8, k);
6887 transmute(r)
6888 }
6889}
6890
6891#[inline]
6895#[target_feature(enable = "avx512f,avx512vl")]
6896#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6897#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0))]
6898#[rustc_legacy_const_generics(4)]
6899pub fn _mm_maskz_fixupimm_pd<const IMM8: i32>(
6900 k: __mmask8,
6901 a: __m128d,
6902 b: __m128d,
6903 c: __m128i,
6904) -> __m128d {
6905 unsafe {
6906 static_assert_uimm_bits!(IMM8, 8);
6907 let a = a.as_f64x2();
6908 let b = b.as_f64x2();
6909 let c = c.as_i64x2();
6910 let r = vfixupimmpdz128(a, b, c, IMM8, k);
6911 transmute(r)
6912 }
6913}
6914
6915#[inline]
6919#[target_feature(enable = "avx512f")]
6920#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6921#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
6922#[rustc_legacy_const_generics(3)]
6923pub fn _mm512_ternarylogic_epi32<const IMM8: i32>(a: __m512i, b: __m512i, c: __m512i) -> __m512i {
6924 unsafe {
6925 static_assert_uimm_bits!(IMM8, 8);
6926 let a = a.as_i32x16();
6927 let b = b.as_i32x16();
6928 let c = c.as_i32x16();
6929 let r = vpternlogd(a, b, c, IMM8);
6930 transmute(r)
6931 }
6932}
6933
6934#[inline]
6938#[target_feature(enable = "avx512f")]
6939#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6940#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
6941#[rustc_legacy_const_generics(4)]
6942pub fn _mm512_mask_ternarylogic_epi32<const IMM8: i32>(
6943 src: __m512i,
6944 k: __mmask16,
6945 a: __m512i,
6946 b: __m512i,
6947) -> __m512i {
6948 unsafe {
6949 static_assert_uimm_bits!(IMM8, 8);
6950 let src = src.as_i32x16();
6951 let a = a.as_i32x16();
6952 let b = b.as_i32x16();
6953 let r = vpternlogd(src, a, b, IMM8);
6954 transmute(simd_select_bitmask(k, r, src))
6955 }
6956}
6957
6958#[inline]
6962#[target_feature(enable = "avx512f")]
6963#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6964#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
6965#[rustc_legacy_const_generics(4)]
6966pub fn _mm512_maskz_ternarylogic_epi32<const IMM8: i32>(
6967 k: __mmask16,
6968 a: __m512i,
6969 b: __m512i,
6970 c: __m512i,
6971) -> __m512i {
6972 unsafe {
6973 static_assert_uimm_bits!(IMM8, 8);
6974 let a = a.as_i32x16();
6975 let b = b.as_i32x16();
6976 let c = c.as_i32x16();
6977 let r = vpternlogd(a, b, c, IMM8);
6978 transmute(simd_select_bitmask(k, r, i32x16::ZERO))
6979 }
6980}
6981
6982#[inline]
6986#[target_feature(enable = "avx512f,avx512vl")]
6987#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
6988#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
6989#[rustc_legacy_const_generics(3)]
6990pub fn _mm256_ternarylogic_epi32<const IMM8: i32>(a: __m256i, b: __m256i, c: __m256i) -> __m256i {
6991 unsafe {
6992 static_assert_uimm_bits!(IMM8, 8);
6993 let a = a.as_i32x8();
6994 let b = b.as_i32x8();
6995 let c = c.as_i32x8();
6996 let r = vpternlogd256(a, b, c, IMM8);
6997 transmute(r)
6998 }
6999}
7000
7001#[inline]
7005#[target_feature(enable = "avx512f,avx512vl")]
7006#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7007#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
7008#[rustc_legacy_const_generics(4)]
7009pub fn _mm256_mask_ternarylogic_epi32<const IMM8: i32>(
7010 src: __m256i,
7011 k: __mmask8,
7012 a: __m256i,
7013 b: __m256i,
7014) -> __m256i {
7015 unsafe {
7016 static_assert_uimm_bits!(IMM8, 8);
7017 let src = src.as_i32x8();
7018 let a = a.as_i32x8();
7019 let b = b.as_i32x8();
7020 let r = vpternlogd256(src, a, b, IMM8);
7021 transmute(simd_select_bitmask(k, r, src))
7022 }
7023}
7024
7025#[inline]
7029#[target_feature(enable = "avx512f,avx512vl")]
7030#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7031#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
7032#[rustc_legacy_const_generics(4)]
7033pub fn _mm256_maskz_ternarylogic_epi32<const IMM8: i32>(
7034 k: __mmask8,
7035 a: __m256i,
7036 b: __m256i,
7037 c: __m256i,
7038) -> __m256i {
7039 unsafe {
7040 static_assert_uimm_bits!(IMM8, 8);
7041 let a = a.as_i32x8();
7042 let b = b.as_i32x8();
7043 let c = c.as_i32x8();
7044 let r = vpternlogd256(a, b, c, IMM8);
7045 transmute(simd_select_bitmask(k, r, i32x8::ZERO))
7046 }
7047}
7048
7049#[inline]
7053#[target_feature(enable = "avx512f,avx512vl")]
7054#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7055#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
7056#[rustc_legacy_const_generics(3)]
7057pub fn _mm_ternarylogic_epi32<const IMM8: i32>(a: __m128i, b: __m128i, c: __m128i) -> __m128i {
7058 unsafe {
7059 static_assert_uimm_bits!(IMM8, 8);
7060 let a = a.as_i32x4();
7061 let b = b.as_i32x4();
7062 let c = c.as_i32x4();
7063 let r = vpternlogd128(a, b, c, IMM8);
7064 transmute(r)
7065 }
7066}
7067
7068#[inline]
7072#[target_feature(enable = "avx512f,avx512vl")]
7073#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7074#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
7075#[rustc_legacy_const_generics(4)]
7076pub fn _mm_mask_ternarylogic_epi32<const IMM8: i32>(
7077 src: __m128i,
7078 k: __mmask8,
7079 a: __m128i,
7080 b: __m128i,
7081) -> __m128i {
7082 unsafe {
7083 static_assert_uimm_bits!(IMM8, 8);
7084 let src = src.as_i32x4();
7085 let a = a.as_i32x4();
7086 let b = b.as_i32x4();
7087 let r = vpternlogd128(src, a, b, IMM8);
7088 transmute(simd_select_bitmask(k, r, src))
7089 }
7090}
7091
7092#[inline]
7096#[target_feature(enable = "avx512f,avx512vl")]
7097#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7098#[cfg_attr(test, assert_instr(vpternlogd, IMM8 = 114))]
7099#[rustc_legacy_const_generics(4)]
7100pub fn _mm_maskz_ternarylogic_epi32<const IMM8: i32>(
7101 k: __mmask8,
7102 a: __m128i,
7103 b: __m128i,
7104 c: __m128i,
7105) -> __m128i {
7106 unsafe {
7107 static_assert_uimm_bits!(IMM8, 8);
7108 let a = a.as_i32x4();
7109 let b = b.as_i32x4();
7110 let c = c.as_i32x4();
7111 let r = vpternlogd128(a, b, c, IMM8);
7112 transmute(simd_select_bitmask(k, r, i32x4::ZERO))
7113 }
7114}
7115
7116#[inline]
7120#[target_feature(enable = "avx512f")]
7121#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7122#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7123#[rustc_legacy_const_generics(3)]
7124pub fn _mm512_ternarylogic_epi64<const IMM8: i32>(a: __m512i, b: __m512i, c: __m512i) -> __m512i {
7125 unsafe {
7126 static_assert_uimm_bits!(IMM8, 8);
7127 let a = a.as_i64x8();
7128 let b = b.as_i64x8();
7129 let c = c.as_i64x8();
7130 let r = vpternlogq(a, b, c, IMM8);
7131 transmute(r)
7132 }
7133}
7134
7135#[inline]
7139#[target_feature(enable = "avx512f")]
7140#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7141#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7142#[rustc_legacy_const_generics(4)]
7143pub fn _mm512_mask_ternarylogic_epi64<const IMM8: i32>(
7144 src: __m512i,
7145 k: __mmask8,
7146 a: __m512i,
7147 b: __m512i,
7148) -> __m512i {
7149 unsafe {
7150 static_assert_uimm_bits!(IMM8, 8);
7151 let src = src.as_i64x8();
7152 let a = a.as_i64x8();
7153 let b = b.as_i64x8();
7154 let r = vpternlogq(src, a, b, IMM8);
7155 transmute(simd_select_bitmask(k, r, src))
7156 }
7157}
7158
7159#[inline]
7163#[target_feature(enable = "avx512f")]
7164#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7165#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7166#[rustc_legacy_const_generics(4)]
7167pub fn _mm512_maskz_ternarylogic_epi64<const IMM8: i32>(
7168 k: __mmask8,
7169 a: __m512i,
7170 b: __m512i,
7171 c: __m512i,
7172) -> __m512i {
7173 unsafe {
7174 static_assert_uimm_bits!(IMM8, 8);
7175 let a = a.as_i64x8();
7176 let b = b.as_i64x8();
7177 let c = c.as_i64x8();
7178 let r = vpternlogq(a, b, c, IMM8);
7179 transmute(simd_select_bitmask(k, r, i64x8::ZERO))
7180 }
7181}
7182
7183#[inline]
7187#[target_feature(enable = "avx512f,avx512vl")]
7188#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7189#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7190#[rustc_legacy_const_generics(3)]
7191pub fn _mm256_ternarylogic_epi64<const IMM8: i32>(a: __m256i, b: __m256i, c: __m256i) -> __m256i {
7192 unsafe {
7193 static_assert_uimm_bits!(IMM8, 8);
7194 let a = a.as_i64x4();
7195 let b = b.as_i64x4();
7196 let c = c.as_i64x4();
7197 let r = vpternlogq256(a, b, c, IMM8);
7198 transmute(r)
7199 }
7200}
7201
7202#[inline]
7206#[target_feature(enable = "avx512f,avx512vl")]
7207#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7208#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7209#[rustc_legacy_const_generics(4)]
7210pub fn _mm256_mask_ternarylogic_epi64<const IMM8: i32>(
7211 src: __m256i,
7212 k: __mmask8,
7213 a: __m256i,
7214 b: __m256i,
7215) -> __m256i {
7216 unsafe {
7217 static_assert_uimm_bits!(IMM8, 8);
7218 let src = src.as_i64x4();
7219 let a = a.as_i64x4();
7220 let b = b.as_i64x4();
7221 let r = vpternlogq256(src, a, b, IMM8);
7222 transmute(simd_select_bitmask(k, r, src))
7223 }
7224}
7225
7226#[inline]
7230#[target_feature(enable = "avx512f,avx512vl")]
7231#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7232#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7233#[rustc_legacy_const_generics(4)]
7234pub fn _mm256_maskz_ternarylogic_epi64<const IMM8: i32>(
7235 k: __mmask8,
7236 a: __m256i,
7237 b: __m256i,
7238 c: __m256i,
7239) -> __m256i {
7240 unsafe {
7241 static_assert_uimm_bits!(IMM8, 8);
7242 let a = a.as_i64x4();
7243 let b = b.as_i64x4();
7244 let c = c.as_i64x4();
7245 let r = vpternlogq256(a, b, c, IMM8);
7246 transmute(simd_select_bitmask(k, r, i64x4::ZERO))
7247 }
7248}
7249
7250#[inline]
7254#[target_feature(enable = "avx512f,avx512vl")]
7255#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7256#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7257#[rustc_legacy_const_generics(3)]
7258pub fn _mm_ternarylogic_epi64<const IMM8: i32>(a: __m128i, b: __m128i, c: __m128i) -> __m128i {
7259 unsafe {
7260 static_assert_uimm_bits!(IMM8, 8);
7261 let a = a.as_i64x2();
7262 let b = b.as_i64x2();
7263 let c = c.as_i64x2();
7264 let r = vpternlogq128(a, b, c, IMM8);
7265 transmute(r)
7266 }
7267}
7268
7269#[inline]
7273#[target_feature(enable = "avx512f,avx512vl")]
7274#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7275#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7276#[rustc_legacy_const_generics(4)]
7277pub fn _mm_mask_ternarylogic_epi64<const IMM8: i32>(
7278 src: __m128i,
7279 k: __mmask8,
7280 a: __m128i,
7281 b: __m128i,
7282) -> __m128i {
7283 unsafe {
7284 static_assert_uimm_bits!(IMM8, 8);
7285 let src = src.as_i64x2();
7286 let a = a.as_i64x2();
7287 let b = b.as_i64x2();
7288 let r = vpternlogq128(src, a, b, IMM8);
7289 transmute(simd_select_bitmask(k, r, src))
7290 }
7291}
7292
7293#[inline]
7297#[target_feature(enable = "avx512f,avx512vl")]
7298#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7299#[cfg_attr(test, assert_instr(vpternlogq, IMM8 = 114))]
7300#[rustc_legacy_const_generics(4)]
7301pub fn _mm_maskz_ternarylogic_epi64<const IMM8: i32>(
7302 k: __mmask8,
7303 a: __m128i,
7304 b: __m128i,
7305 c: __m128i,
7306) -> __m128i {
7307 unsafe {
7308 static_assert_uimm_bits!(IMM8, 8);
7309 let a = a.as_i64x2();
7310 let b = b.as_i64x2();
7311 let c = c.as_i64x2();
7312 let r = vpternlogq128(a, b, c, IMM8);
7313 transmute(simd_select_bitmask(k, r, i64x2::ZERO))
7314 }
7315}
7316
7317#[inline]
7330#[target_feature(enable = "avx512f")]
7331#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7332#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7333#[rustc_legacy_const_generics(1, 2)]
7334pub fn _mm512_getmant_ps<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
7335 a: __m512,
7336) -> __m512 {
7337 unsafe {
7338 static_assert_uimm_bits!(NORM, 4);
7339 static_assert_uimm_bits!(SIGN, 2);
7340 let a = a.as_f32x16();
7341 let zero = f32x16::ZERO;
7342 let r = vgetmantps(
7343 a,
7344 SIGN << 2 | NORM,
7345 zero,
7346 0b11111111_11111111,
7347 _MM_FROUND_CUR_DIRECTION,
7348 );
7349 transmute(r)
7350 }
7351}
7352
7353#[inline]
7366#[target_feature(enable = "avx512f")]
7367#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7368#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7369#[rustc_legacy_const_generics(3, 4)]
7370pub fn _mm512_mask_getmant_ps<
7371 const NORM: _MM_MANTISSA_NORM_ENUM,
7372 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7373>(
7374 src: __m512,
7375 k: __mmask16,
7376 a: __m512,
7377) -> __m512 {
7378 unsafe {
7379 static_assert_uimm_bits!(NORM, 4);
7380 static_assert_uimm_bits!(SIGN, 2);
7381 let a = a.as_f32x16();
7382 let src = src.as_f32x16();
7383 let r = vgetmantps(a, SIGN << 2 | NORM, src, k, _MM_FROUND_CUR_DIRECTION);
7384 transmute(r)
7385 }
7386}
7387
7388#[inline]
7401#[target_feature(enable = "avx512f")]
7402#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7403#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7404#[rustc_legacy_const_generics(2, 3)]
7405pub fn _mm512_maskz_getmant_ps<
7406 const NORM: _MM_MANTISSA_NORM_ENUM,
7407 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7408>(
7409 k: __mmask16,
7410 a: __m512,
7411) -> __m512 {
7412 unsafe {
7413 static_assert_uimm_bits!(NORM, 4);
7414 static_assert_uimm_bits!(SIGN, 2);
7415 let a = a.as_f32x16();
7416 let r = vgetmantps(
7417 a,
7418 SIGN << 2 | NORM,
7419 f32x16::ZERO,
7420 k,
7421 _MM_FROUND_CUR_DIRECTION,
7422 );
7423 transmute(r)
7424 }
7425}
7426
7427#[inline]
7440#[target_feature(enable = "avx512f,avx512vl")]
7441#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7442#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7443#[rustc_legacy_const_generics(1, 2)]
7444pub fn _mm256_getmant_ps<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
7445 a: __m256,
7446) -> __m256 {
7447 unsafe {
7448 static_assert_uimm_bits!(NORM, 4);
7449 static_assert_uimm_bits!(SIGN, 2);
7450 let a = a.as_f32x8();
7451 let r = vgetmantps256(a, SIGN << 2 | NORM, f32x8::ZERO, 0b11111111);
7452 transmute(r)
7453 }
7454}
7455
7456#[inline]
7469#[target_feature(enable = "avx512f,avx512vl")]
7470#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7471#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7472#[rustc_legacy_const_generics(3, 4)]
7473pub fn _mm256_mask_getmant_ps<
7474 const NORM: _MM_MANTISSA_NORM_ENUM,
7475 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7476>(
7477 src: __m256,
7478 k: __mmask8,
7479 a: __m256,
7480) -> __m256 {
7481 unsafe {
7482 static_assert_uimm_bits!(NORM, 4);
7483 static_assert_uimm_bits!(SIGN, 2);
7484 let a = a.as_f32x8();
7485 let src = src.as_f32x8();
7486 let r = vgetmantps256(a, SIGN << 2 | NORM, src, k);
7487 transmute(r)
7488 }
7489}
7490
7491#[inline]
7504#[target_feature(enable = "avx512f,avx512vl")]
7505#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7506#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7507#[rustc_legacy_const_generics(2, 3)]
7508pub fn _mm256_maskz_getmant_ps<
7509 const NORM: _MM_MANTISSA_NORM_ENUM,
7510 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7511>(
7512 k: __mmask8,
7513 a: __m256,
7514) -> __m256 {
7515 unsafe {
7516 static_assert_uimm_bits!(NORM, 4);
7517 static_assert_uimm_bits!(SIGN, 2);
7518 let a = a.as_f32x8();
7519 let r = vgetmantps256(a, SIGN << 2 | NORM, f32x8::ZERO, k);
7520 transmute(r)
7521 }
7522}
7523
7524#[inline]
7537#[target_feature(enable = "avx512f,avx512vl")]
7538#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7539#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7540#[rustc_legacy_const_generics(1, 2)]
7541pub fn _mm_getmant_ps<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
7542 a: __m128,
7543) -> __m128 {
7544 unsafe {
7545 static_assert_uimm_bits!(NORM, 4);
7546 static_assert_uimm_bits!(SIGN, 2);
7547 let a = a.as_f32x4();
7548 let r = vgetmantps128(a, SIGN << 2 | NORM, f32x4::ZERO, 0b00001111);
7549 transmute(r)
7550 }
7551}
7552
7553#[inline]
7566#[target_feature(enable = "avx512f,avx512vl")]
7567#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7568#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7569#[rustc_legacy_const_generics(3, 4)]
7570pub fn _mm_mask_getmant_ps<
7571 const NORM: _MM_MANTISSA_NORM_ENUM,
7572 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7573>(
7574 src: __m128,
7575 k: __mmask8,
7576 a: __m128,
7577) -> __m128 {
7578 unsafe {
7579 static_assert_uimm_bits!(NORM, 4);
7580 static_assert_uimm_bits!(SIGN, 2);
7581 let a = a.as_f32x4();
7582 let src = src.as_f32x4();
7583 let r = vgetmantps128(a, SIGN << 2 | NORM, src, k);
7584 transmute(r)
7585 }
7586}
7587
7588#[inline]
7601#[target_feature(enable = "avx512f,avx512vl")]
7602#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7603#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0))]
7604#[rustc_legacy_const_generics(2, 3)]
7605pub fn _mm_maskz_getmant_ps<
7606 const NORM: _MM_MANTISSA_NORM_ENUM,
7607 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7608>(
7609 k: __mmask8,
7610 a: __m128,
7611) -> __m128 {
7612 unsafe {
7613 static_assert_uimm_bits!(NORM, 4);
7614 static_assert_uimm_bits!(SIGN, 2);
7615 let a = a.as_f32x4();
7616 let r = vgetmantps128(a, SIGN << 2 | NORM, f32x4::ZERO, k);
7617 transmute(r)
7618 }
7619}
7620
7621#[inline]
7634#[target_feature(enable = "avx512f")]
7635#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7636#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7637#[rustc_legacy_const_generics(1, 2)]
7638pub fn _mm512_getmant_pd<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
7639 a: __m512d,
7640) -> __m512d {
7641 unsafe {
7642 static_assert_uimm_bits!(NORM, 4);
7643 static_assert_uimm_bits!(SIGN, 2);
7644 let a = a.as_f64x8();
7645 let zero = f64x8::ZERO;
7646 let r = vgetmantpd(
7647 a,
7648 SIGN << 2 | NORM,
7649 zero,
7650 0b11111111,
7651 _MM_FROUND_CUR_DIRECTION,
7652 );
7653 transmute(r)
7654 }
7655}
7656
7657#[inline]
7670#[target_feature(enable = "avx512f")]
7671#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7672#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7673#[rustc_legacy_const_generics(3, 4)]
7674pub fn _mm512_mask_getmant_pd<
7675 const NORM: _MM_MANTISSA_NORM_ENUM,
7676 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7677>(
7678 src: __m512d,
7679 k: __mmask8,
7680 a: __m512d,
7681) -> __m512d {
7682 unsafe {
7683 static_assert_uimm_bits!(NORM, 4);
7684 static_assert_uimm_bits!(SIGN, 2);
7685 let a = a.as_f64x8();
7686 let src = src.as_f64x8();
7687 let r = vgetmantpd(a, SIGN << 2 | NORM, src, k, _MM_FROUND_CUR_DIRECTION);
7688 transmute(r)
7689 }
7690}
7691
7692#[inline]
7705#[target_feature(enable = "avx512f")]
7706#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7707#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7708#[rustc_legacy_const_generics(2, 3)]
7709pub fn _mm512_maskz_getmant_pd<
7710 const NORM: _MM_MANTISSA_NORM_ENUM,
7711 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7712>(
7713 k: __mmask8,
7714 a: __m512d,
7715) -> __m512d {
7716 unsafe {
7717 static_assert_uimm_bits!(NORM, 4);
7718 static_assert_uimm_bits!(SIGN, 2);
7719 let a = a.as_f64x8();
7720 let r = vgetmantpd(
7721 a,
7722 SIGN << 2 | NORM,
7723 f64x8::ZERO,
7724 k,
7725 _MM_FROUND_CUR_DIRECTION,
7726 );
7727 transmute(r)
7728 }
7729}
7730
7731#[inline]
7744#[target_feature(enable = "avx512f,avx512vl")]
7745#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7746#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7747#[rustc_legacy_const_generics(1, 2)]
7748pub fn _mm256_getmant_pd<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
7749 a: __m256d,
7750) -> __m256d {
7751 unsafe {
7752 static_assert_uimm_bits!(NORM, 4);
7753 static_assert_uimm_bits!(SIGN, 2);
7754 let a = a.as_f64x4();
7755 let r = vgetmantpd256(a, SIGN << 2 | NORM, f64x4::ZERO, 0b00001111);
7756 transmute(r)
7757 }
7758}
7759
7760#[inline]
7773#[target_feature(enable = "avx512f,avx512vl")]
7774#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7775#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7776#[rustc_legacy_const_generics(3, 4)]
7777pub fn _mm256_mask_getmant_pd<
7778 const NORM: _MM_MANTISSA_NORM_ENUM,
7779 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7780>(
7781 src: __m256d,
7782 k: __mmask8,
7783 a: __m256d,
7784) -> __m256d {
7785 unsafe {
7786 static_assert_uimm_bits!(NORM, 4);
7787 static_assert_uimm_bits!(SIGN, 2);
7788 let a = a.as_f64x4();
7789 let src = src.as_f64x4();
7790 let r = vgetmantpd256(a, SIGN << 2 | NORM, src, k);
7791 transmute(r)
7792 }
7793}
7794
7795#[inline]
7808#[target_feature(enable = "avx512f,avx512vl")]
7809#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7810#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7811#[rustc_legacy_const_generics(2, 3)]
7812pub fn _mm256_maskz_getmant_pd<
7813 const NORM: _MM_MANTISSA_NORM_ENUM,
7814 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7815>(
7816 k: __mmask8,
7817 a: __m256d,
7818) -> __m256d {
7819 unsafe {
7820 static_assert_uimm_bits!(NORM, 4);
7821 static_assert_uimm_bits!(SIGN, 2);
7822 let a = a.as_f64x4();
7823 let r = vgetmantpd256(a, SIGN << 2 | NORM, f64x4::ZERO, k);
7824 transmute(r)
7825 }
7826}
7827
7828#[inline]
7841#[target_feature(enable = "avx512f,avx512vl")]
7842#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7843#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7844#[rustc_legacy_const_generics(1, 2)]
7845pub fn _mm_getmant_pd<const NORM: _MM_MANTISSA_NORM_ENUM, const SIGN: _MM_MANTISSA_SIGN_ENUM>(
7846 a: __m128d,
7847) -> __m128d {
7848 unsafe {
7849 static_assert_uimm_bits!(NORM, 4);
7850 static_assert_uimm_bits!(SIGN, 2);
7851 let a = a.as_f64x2();
7852 let r = vgetmantpd128(a, SIGN << 2 | NORM, f64x2::ZERO, 0b00000011);
7853 transmute(r)
7854 }
7855}
7856
7857#[inline]
7870#[target_feature(enable = "avx512f,avx512vl")]
7871#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7872#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7873#[rustc_legacy_const_generics(3, 4)]
7874pub fn _mm_mask_getmant_pd<
7875 const NORM: _MM_MANTISSA_NORM_ENUM,
7876 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7877>(
7878 src: __m128d,
7879 k: __mmask8,
7880 a: __m128d,
7881) -> __m128d {
7882 unsafe {
7883 static_assert_uimm_bits!(NORM, 4);
7884 static_assert_uimm_bits!(SIGN, 2);
7885 let a = a.as_f64x2();
7886 let src = src.as_f64x2();
7887 let r = vgetmantpd128(a, SIGN << 2 | NORM, src, k);
7888 transmute(r)
7889 }
7890}
7891
7892#[inline]
7905#[target_feature(enable = "avx512f,avx512vl")]
7906#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7907#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0))]
7908#[rustc_legacy_const_generics(2, 3)]
7909pub fn _mm_maskz_getmant_pd<
7910 const NORM: _MM_MANTISSA_NORM_ENUM,
7911 const SIGN: _MM_MANTISSA_SIGN_ENUM,
7912>(
7913 k: __mmask8,
7914 a: __m128d,
7915) -> __m128d {
7916 unsafe {
7917 static_assert_uimm_bits!(NORM, 4);
7918 static_assert_uimm_bits!(SIGN, 2);
7919 let a = a.as_f64x2();
7920 let r = vgetmantpd128(a, SIGN << 2 | NORM, f64x2::ZERO, k);
7921 transmute(r)
7922 }
7923}
7924
7925#[inline]
7936#[target_feature(enable = "avx512f")]
7937#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7938#[cfg_attr(test, assert_instr(vaddps, ROUNDING = 8))]
7939#[rustc_legacy_const_generics(2)]
7940pub fn _mm512_add_round_ps<const ROUNDING: i32>(a: __m512, b: __m512) -> __m512 {
7941 unsafe {
7942 static_assert_rounding!(ROUNDING);
7943 let a = a.as_f32x16();
7944 let b = b.as_f32x16();
7945 let r = vaddps(a, b, ROUNDING);
7946 transmute(r)
7947 }
7948}
7949
7950#[inline]
7961#[target_feature(enable = "avx512f")]
7962#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7963#[cfg_attr(test, assert_instr(vaddps, ROUNDING = 8))]
7964#[rustc_legacy_const_generics(4)]
7965pub fn _mm512_mask_add_round_ps<const ROUNDING: i32>(
7966 src: __m512,
7967 k: __mmask16,
7968 a: __m512,
7969 b: __m512,
7970) -> __m512 {
7971 unsafe {
7972 static_assert_rounding!(ROUNDING);
7973 let a = a.as_f32x16();
7974 let b = b.as_f32x16();
7975 let r = vaddps(a, b, ROUNDING);
7976 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
7977 }
7978}
7979
7980#[inline]
7991#[target_feature(enable = "avx512f")]
7992#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
7993#[cfg_attr(test, assert_instr(vaddps, ROUNDING = 8))]
7994#[rustc_legacy_const_generics(3)]
7995pub fn _mm512_maskz_add_round_ps<const ROUNDING: i32>(
7996 k: __mmask16,
7997 a: __m512,
7998 b: __m512,
7999) -> __m512 {
8000 unsafe {
8001 static_assert_rounding!(ROUNDING);
8002 let a = a.as_f32x16();
8003 let b = b.as_f32x16();
8004 let r = vaddps(a, b, ROUNDING);
8005 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
8006 }
8007}
8008
8009#[inline]
8020#[target_feature(enable = "avx512f")]
8021#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8022#[cfg_attr(test, assert_instr(vaddpd, ROUNDING = 8))]
8023#[rustc_legacy_const_generics(2)]
8024pub fn _mm512_add_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d) -> __m512d {
8025 unsafe {
8026 static_assert_rounding!(ROUNDING);
8027 let a = a.as_f64x8();
8028 let b = b.as_f64x8();
8029 let r = vaddpd(a, b, ROUNDING);
8030 transmute(r)
8031 }
8032}
8033
8034#[inline]
8045#[target_feature(enable = "avx512f")]
8046#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8047#[cfg_attr(test, assert_instr(vaddpd, ROUNDING = 8))]
8048#[rustc_legacy_const_generics(4)]
8049pub fn _mm512_mask_add_round_pd<const ROUNDING: i32>(
8050 src: __m512d,
8051 k: __mmask8,
8052 a: __m512d,
8053 b: __m512d,
8054) -> __m512d {
8055 unsafe {
8056 static_assert_rounding!(ROUNDING);
8057 let a = a.as_f64x8();
8058 let b = b.as_f64x8();
8059 let r = vaddpd(a, b, ROUNDING);
8060 transmute(simd_select_bitmask(k, r, src.as_f64x8()))
8061 }
8062}
8063
8064#[inline]
8075#[target_feature(enable = "avx512f")]
8076#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8077#[cfg_attr(test, assert_instr(vaddpd, ROUNDING = 8))]
8078#[rustc_legacy_const_generics(3)]
8079pub fn _mm512_maskz_add_round_pd<const ROUNDING: i32>(
8080 k: __mmask8,
8081 a: __m512d,
8082 b: __m512d,
8083) -> __m512d {
8084 unsafe {
8085 static_assert_rounding!(ROUNDING);
8086 let a = a.as_f64x8();
8087 let b = b.as_f64x8();
8088 let r = vaddpd(a, b, ROUNDING);
8089 transmute(simd_select_bitmask(k, r, f64x8::ZERO))
8090 }
8091}
8092
8093#[inline]
8104#[target_feature(enable = "avx512f")]
8105#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8106#[cfg_attr(test, assert_instr(vsubps, ROUNDING = 8))]
8107#[rustc_legacy_const_generics(2)]
8108pub fn _mm512_sub_round_ps<const ROUNDING: i32>(a: __m512, b: __m512) -> __m512 {
8109 unsafe {
8110 static_assert_rounding!(ROUNDING);
8111 let a = a.as_f32x16();
8112 let b = b.as_f32x16();
8113 let r = vsubps(a, b, ROUNDING);
8114 transmute(r)
8115 }
8116}
8117
8118#[inline]
8129#[target_feature(enable = "avx512f")]
8130#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8131#[cfg_attr(test, assert_instr(vsubps, ROUNDING = 8))]
8132#[rustc_legacy_const_generics(4)]
8133pub fn _mm512_mask_sub_round_ps<const ROUNDING: i32>(
8134 src: __m512,
8135 k: __mmask16,
8136 a: __m512,
8137 b: __m512,
8138) -> __m512 {
8139 unsafe {
8140 static_assert_rounding!(ROUNDING);
8141 let a = a.as_f32x16();
8142 let b = b.as_f32x16();
8143 let r = vsubps(a, b, ROUNDING);
8144 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
8145 }
8146}
8147
8148#[inline]
8159#[target_feature(enable = "avx512f")]
8160#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8161#[cfg_attr(test, assert_instr(vsubps, ROUNDING = 8))]
8162#[rustc_legacy_const_generics(3)]
8163pub fn _mm512_maskz_sub_round_ps<const ROUNDING: i32>(
8164 k: __mmask16,
8165 a: __m512,
8166 b: __m512,
8167) -> __m512 {
8168 unsafe {
8169 static_assert_rounding!(ROUNDING);
8170 let a = a.as_f32x16();
8171 let b = b.as_f32x16();
8172 let r = vsubps(a, b, ROUNDING);
8173 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
8174 }
8175}
8176
8177#[inline]
8188#[target_feature(enable = "avx512f")]
8189#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8190#[cfg_attr(test, assert_instr(vsubpd, ROUNDING = 8))]
8191#[rustc_legacy_const_generics(2)]
8192pub fn _mm512_sub_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d) -> __m512d {
8193 unsafe {
8194 static_assert_rounding!(ROUNDING);
8195 let a = a.as_f64x8();
8196 let b = b.as_f64x8();
8197 let r = vsubpd(a, b, ROUNDING);
8198 transmute(r)
8199 }
8200}
8201
8202#[inline]
8213#[target_feature(enable = "avx512f")]
8214#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8215#[cfg_attr(test, assert_instr(vsubpd, ROUNDING = 8))]
8216#[rustc_legacy_const_generics(4)]
8217pub fn _mm512_mask_sub_round_pd<const ROUNDING: i32>(
8218 src: __m512d,
8219 k: __mmask8,
8220 a: __m512d,
8221 b: __m512d,
8222) -> __m512d {
8223 unsafe {
8224 static_assert_rounding!(ROUNDING);
8225 let a = a.as_f64x8();
8226 let b = b.as_f64x8();
8227 let r = vsubpd(a, b, ROUNDING);
8228 transmute(simd_select_bitmask(k, r, src.as_f64x8()))
8229 }
8230}
8231
8232#[inline]
8243#[target_feature(enable = "avx512f")]
8244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8245#[cfg_attr(test, assert_instr(vsubpd, ROUNDING = 8))]
8246#[rustc_legacy_const_generics(3)]
8247pub fn _mm512_maskz_sub_round_pd<const ROUNDING: i32>(
8248 k: __mmask8,
8249 a: __m512d,
8250 b: __m512d,
8251) -> __m512d {
8252 unsafe {
8253 static_assert_rounding!(ROUNDING);
8254 let a = a.as_f64x8();
8255 let b = b.as_f64x8();
8256 let r = vsubpd(a, b, ROUNDING);
8257 transmute(simd_select_bitmask(k, r, f64x8::ZERO))
8258 }
8259}
8260
8261#[inline]
8272#[target_feature(enable = "avx512f")]
8273#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8274#[cfg_attr(test, assert_instr(vmulps, ROUNDING = 8))]
8275#[rustc_legacy_const_generics(2)]
8276pub fn _mm512_mul_round_ps<const ROUNDING: i32>(a: __m512, b: __m512) -> __m512 {
8277 unsafe {
8278 static_assert_rounding!(ROUNDING);
8279 let a = a.as_f32x16();
8280 let b = b.as_f32x16();
8281 let r = vmulps(a, b, ROUNDING);
8282 transmute(r)
8283 }
8284}
8285
8286#[inline]
8297#[target_feature(enable = "avx512f")]
8298#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8299#[cfg_attr(test, assert_instr(vmulps, ROUNDING = 8))]
8300#[rustc_legacy_const_generics(4)]
8301pub fn _mm512_mask_mul_round_ps<const ROUNDING: i32>(
8302 src: __m512,
8303 k: __mmask16,
8304 a: __m512,
8305 b: __m512,
8306) -> __m512 {
8307 unsafe {
8308 static_assert_rounding!(ROUNDING);
8309 let a = a.as_f32x16();
8310 let b = b.as_f32x16();
8311 let r = vmulps(a, b, ROUNDING);
8312 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
8313 }
8314}
8315
8316#[inline]
8327#[target_feature(enable = "avx512f")]
8328#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8329#[cfg_attr(test, assert_instr(vmulps, ROUNDING = 8))]
8330#[rustc_legacy_const_generics(3)]
8331pub fn _mm512_maskz_mul_round_ps<const ROUNDING: i32>(
8332 k: __mmask16,
8333 a: __m512,
8334 b: __m512,
8335) -> __m512 {
8336 unsafe {
8337 static_assert_rounding!(ROUNDING);
8338 let a = a.as_f32x16();
8339 let b = b.as_f32x16();
8340 let r = vmulps(a, b, ROUNDING);
8341 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
8342 }
8343}
8344
8345#[inline]
8356#[target_feature(enable = "avx512f")]
8357#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8358#[cfg_attr(test, assert_instr(vmulpd, ROUNDING = 8))]
8359#[rustc_legacy_const_generics(2)]
8360pub fn _mm512_mul_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d) -> __m512d {
8361 unsafe {
8362 static_assert_rounding!(ROUNDING);
8363 let a = a.as_f64x8();
8364 let b = b.as_f64x8();
8365 let r = vmulpd(a, b, ROUNDING);
8366 transmute(r)
8367 }
8368}
8369
8370#[inline]
8381#[target_feature(enable = "avx512f")]
8382#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8383#[cfg_attr(test, assert_instr(vmulpd, ROUNDING = 8))]
8384#[rustc_legacy_const_generics(4)]
8385pub fn _mm512_mask_mul_round_pd<const ROUNDING: i32>(
8386 src: __m512d,
8387 k: __mmask8,
8388 a: __m512d,
8389 b: __m512d,
8390) -> __m512d {
8391 unsafe {
8392 static_assert_rounding!(ROUNDING);
8393 let a = a.as_f64x8();
8394 let b = b.as_f64x8();
8395 let r = vmulpd(a, b, ROUNDING);
8396 transmute(simd_select_bitmask(k, r, src.as_f64x8()))
8397 }
8398}
8399
8400#[inline]
8411#[target_feature(enable = "avx512f")]
8412#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8413#[cfg_attr(test, assert_instr(vmulpd, ROUNDING = 8))]
8414#[rustc_legacy_const_generics(3)]
8415pub fn _mm512_maskz_mul_round_pd<const ROUNDING: i32>(
8416 k: __mmask8,
8417 a: __m512d,
8418 b: __m512d,
8419) -> __m512d {
8420 unsafe {
8421 static_assert_rounding!(ROUNDING);
8422 let a = a.as_f64x8();
8423 let b = b.as_f64x8();
8424 let r = vmulpd(a, b, ROUNDING);
8425 transmute(simd_select_bitmask(k, r, f64x8::ZERO))
8426 }
8427}
8428
8429#[inline]
8440#[target_feature(enable = "avx512f")]
8441#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8442#[cfg_attr(test, assert_instr(vdivps, ROUNDING = 8))]
8443#[rustc_legacy_const_generics(2)]
8444pub fn _mm512_div_round_ps<const ROUNDING: i32>(a: __m512, b: __m512) -> __m512 {
8445 unsafe {
8446 static_assert_rounding!(ROUNDING);
8447 let a = a.as_f32x16();
8448 let b = b.as_f32x16();
8449 let r = vdivps(a, b, ROUNDING);
8450 transmute(r)
8451 }
8452}
8453
8454#[inline]
8465#[target_feature(enable = "avx512f")]
8466#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8467#[cfg_attr(test, assert_instr(vdivps, ROUNDING = 8))]
8468#[rustc_legacy_const_generics(4)]
8469pub fn _mm512_mask_div_round_ps<const ROUNDING: i32>(
8470 src: __m512,
8471 k: __mmask16,
8472 a: __m512,
8473 b: __m512,
8474) -> __m512 {
8475 unsafe {
8476 static_assert_rounding!(ROUNDING);
8477 let a = a.as_f32x16();
8478 let b = b.as_f32x16();
8479 let r = vdivps(a, b, ROUNDING);
8480 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
8481 }
8482}
8483
8484#[inline]
8495#[target_feature(enable = "avx512f")]
8496#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8497#[cfg_attr(test, assert_instr(vdivps, ROUNDING = 8))]
8498#[rustc_legacy_const_generics(3)]
8499pub fn _mm512_maskz_div_round_ps<const ROUNDING: i32>(
8500 k: __mmask16,
8501 a: __m512,
8502 b: __m512,
8503) -> __m512 {
8504 unsafe {
8505 static_assert_rounding!(ROUNDING);
8506 let a = a.as_f32x16();
8507 let b = b.as_f32x16();
8508 let r = vdivps(a, b, ROUNDING);
8509 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
8510 }
8511}
8512
8513#[inline]
8524#[target_feature(enable = "avx512f")]
8525#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8526#[cfg_attr(test, assert_instr(vdivpd, ROUNDING = 8))]
8527#[rustc_legacy_const_generics(2)]
8528pub fn _mm512_div_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d) -> __m512d {
8529 unsafe {
8530 static_assert_rounding!(ROUNDING);
8531 let a = a.as_f64x8();
8532 let b = b.as_f64x8();
8533 let r = vdivpd(a, b, ROUNDING);
8534 transmute(r)
8535 }
8536}
8537
8538#[inline]
8549#[target_feature(enable = "avx512f")]
8550#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8551#[cfg_attr(test, assert_instr(vdivpd, ROUNDING = 8))]
8552#[rustc_legacy_const_generics(4)]
8553pub fn _mm512_mask_div_round_pd<const ROUNDING: i32>(
8554 src: __m512d,
8555 k: __mmask8,
8556 a: __m512d,
8557 b: __m512d,
8558) -> __m512d {
8559 unsafe {
8560 static_assert_rounding!(ROUNDING);
8561 let a = a.as_f64x8();
8562 let b = b.as_f64x8();
8563 let r = vdivpd(a, b, ROUNDING);
8564 transmute(simd_select_bitmask(k, r, src.as_f64x8()))
8565 }
8566}
8567
8568#[inline]
8579#[target_feature(enable = "avx512f")]
8580#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8581#[cfg_attr(test, assert_instr(vdivpd, ROUNDING = 8))]
8582#[rustc_legacy_const_generics(3)]
8583pub fn _mm512_maskz_div_round_pd<const ROUNDING: i32>(
8584 k: __mmask8,
8585 a: __m512d,
8586 b: __m512d,
8587) -> __m512d {
8588 unsafe {
8589 static_assert_rounding!(ROUNDING);
8590 let a = a.as_f64x8();
8591 let b = b.as_f64x8();
8592 let r = vdivpd(a, b, ROUNDING);
8593 transmute(simd_select_bitmask(k, r, f64x8::ZERO))
8594 }
8595}
8596
8597#[inline]
8608#[target_feature(enable = "avx512f")]
8609#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8610#[cfg_attr(test, assert_instr(vsqrtps, ROUNDING = 8))]
8611#[rustc_legacy_const_generics(1)]
8612pub fn _mm512_sqrt_round_ps<const ROUNDING: i32>(a: __m512) -> __m512 {
8613 unsafe {
8614 static_assert_rounding!(ROUNDING);
8615 let a = a.as_f32x16();
8616 let r = vsqrtps(a, ROUNDING);
8617 transmute(r)
8618 }
8619}
8620
8621#[inline]
8632#[target_feature(enable = "avx512f")]
8633#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8634#[cfg_attr(test, assert_instr(vsqrtps, ROUNDING = 8))]
8635#[rustc_legacy_const_generics(3)]
8636pub fn _mm512_mask_sqrt_round_ps<const ROUNDING: i32>(
8637 src: __m512,
8638 k: __mmask16,
8639 a: __m512,
8640) -> __m512 {
8641 unsafe {
8642 static_assert_rounding!(ROUNDING);
8643 let a = a.as_f32x16();
8644 let r = vsqrtps(a, ROUNDING);
8645 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
8646 }
8647}
8648
8649#[inline]
8660#[target_feature(enable = "avx512f")]
8661#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8662#[cfg_attr(test, assert_instr(vsqrtps, ROUNDING = 8))]
8663#[rustc_legacy_const_generics(2)]
8664pub fn _mm512_maskz_sqrt_round_ps<const ROUNDING: i32>(k: __mmask16, a: __m512) -> __m512 {
8665 unsafe {
8666 static_assert_rounding!(ROUNDING);
8667 let a = a.as_f32x16();
8668 let r = vsqrtps(a, ROUNDING);
8669 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
8670 }
8671}
8672
8673#[inline]
8684#[target_feature(enable = "avx512f")]
8685#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8686#[cfg_attr(test, assert_instr(vsqrtpd, ROUNDING = 8))]
8687#[rustc_legacy_const_generics(1)]
8688pub fn _mm512_sqrt_round_pd<const ROUNDING: i32>(a: __m512d) -> __m512d {
8689 unsafe {
8690 static_assert_rounding!(ROUNDING);
8691 let a = a.as_f64x8();
8692 let r = vsqrtpd(a, ROUNDING);
8693 transmute(r)
8694 }
8695}
8696
8697#[inline]
8708#[target_feature(enable = "avx512f")]
8709#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8710#[cfg_attr(test, assert_instr(vsqrtpd, ROUNDING = 8))]
8711#[rustc_legacy_const_generics(3)]
8712pub fn _mm512_mask_sqrt_round_pd<const ROUNDING: i32>(
8713 src: __m512d,
8714 k: __mmask8,
8715 a: __m512d,
8716) -> __m512d {
8717 unsafe {
8718 static_assert_rounding!(ROUNDING);
8719 let a = a.as_f64x8();
8720 let r = vsqrtpd(a, ROUNDING);
8721 transmute(simd_select_bitmask(k, r, src.as_f64x8()))
8722 }
8723}
8724
8725#[inline]
8736#[target_feature(enable = "avx512f")]
8737#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8738#[cfg_attr(test, assert_instr(vsqrtpd, ROUNDING = 8))]
8739#[rustc_legacy_const_generics(2)]
8740pub fn _mm512_maskz_sqrt_round_pd<const ROUNDING: i32>(k: __mmask8, a: __m512d) -> __m512d {
8741 unsafe {
8742 static_assert_rounding!(ROUNDING);
8743 let a = a.as_f64x8();
8744 let r = vsqrtpd(a, ROUNDING);
8745 transmute(simd_select_bitmask(k, r, f64x8::ZERO))
8746 }
8747}
8748
8749#[inline]
8760#[target_feature(enable = "avx512f")]
8761#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8762#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
8764pub fn _mm512_fmadd_round_ps<const ROUNDING: i32>(a: __m512, b: __m512, c: __m512) -> __m512 {
8765 unsafe {
8766 static_assert_rounding!(ROUNDING);
8767 vfmadd132psround(a, b, c, ROUNDING)
8768 }
8769}
8770
8771#[inline]
8782#[target_feature(enable = "avx512f")]
8783#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8784#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
8786pub fn _mm512_mask_fmadd_round_ps<const ROUNDING: i32>(
8787 a: __m512,
8788 k: __mmask16,
8789 b: __m512,
8790 c: __m512,
8791) -> __m512 {
8792 unsafe {
8793 static_assert_rounding!(ROUNDING);
8794 simd_select_bitmask(k, vfmadd132psround(a, b, c, ROUNDING), a)
8795 }
8796}
8797
8798#[inline]
8809#[target_feature(enable = "avx512f")]
8810#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8811#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
8813pub fn _mm512_maskz_fmadd_round_ps<const ROUNDING: i32>(
8814 k: __mmask16,
8815 a: __m512,
8816 b: __m512,
8817 c: __m512,
8818) -> __m512 {
8819 unsafe {
8820 static_assert_rounding!(ROUNDING);
8821 simd_select_bitmask(k, vfmadd132psround(a, b, c, ROUNDING), _mm512_setzero_ps())
8822 }
8823}
8824
8825#[inline]
8836#[target_feature(enable = "avx512f")]
8837#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8838#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
8840pub fn _mm512_mask3_fmadd_round_ps<const ROUNDING: i32>(
8841 a: __m512,
8842 b: __m512,
8843 c: __m512,
8844 k: __mmask16,
8845) -> __m512 {
8846 unsafe {
8847 static_assert_rounding!(ROUNDING);
8848 simd_select_bitmask(k, vfmadd132psround(a, b, c, ROUNDING), c)
8849 }
8850}
8851
8852#[inline]
8863#[target_feature(enable = "avx512f")]
8864#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8865#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
8867pub fn _mm512_fmadd_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
8868 unsafe {
8869 static_assert_rounding!(ROUNDING);
8870 vfmadd132pdround(a, b, c, ROUNDING)
8871 }
8872}
8873
8874#[inline]
8885#[target_feature(enable = "avx512f")]
8886#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8887#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
8889pub fn _mm512_mask_fmadd_round_pd<const ROUNDING: i32>(
8890 a: __m512d,
8891 k: __mmask8,
8892 b: __m512d,
8893 c: __m512d,
8894) -> __m512d {
8895 unsafe {
8896 static_assert_rounding!(ROUNDING);
8897 simd_select_bitmask(k, vfmadd132pdround(a, b, c, ROUNDING), a)
8898 }
8899}
8900
8901#[inline]
8912#[target_feature(enable = "avx512f")]
8913#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8914#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
8916pub fn _mm512_maskz_fmadd_round_pd<const ROUNDING: i32>(
8917 k: __mmask8,
8918 a: __m512d,
8919 b: __m512d,
8920 c: __m512d,
8921) -> __m512d {
8922 unsafe {
8923 static_assert_rounding!(ROUNDING);
8924 simd_select_bitmask(k, vfmadd132pdround(a, b, c, ROUNDING), _mm512_setzero_pd())
8925 }
8926}
8927
8928#[inline]
8939#[target_feature(enable = "avx512f")]
8940#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8941#[cfg_attr(test, assert_instr(vfmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
8943pub fn _mm512_mask3_fmadd_round_pd<const ROUNDING: i32>(
8944 a: __m512d,
8945 b: __m512d,
8946 c: __m512d,
8947 k: __mmask8,
8948) -> __m512d {
8949 unsafe {
8950 static_assert_rounding!(ROUNDING);
8951 simd_select_bitmask(k, vfmadd132pdround(a, b, c, ROUNDING), c)
8952 }
8953}
8954
8955#[inline]
8966#[target_feature(enable = "avx512f")]
8967#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8968#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
8970pub fn _mm512_fmsub_round_ps<const ROUNDING: i32>(a: __m512, b: __m512, c: __m512) -> __m512 {
8971 unsafe {
8972 static_assert_rounding!(ROUNDING);
8973 vfmadd132psround(a, b, simd_neg(c), ROUNDING)
8974 }
8975}
8976
8977#[inline]
8988#[target_feature(enable = "avx512f")]
8989#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
8990#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
8992pub fn _mm512_mask_fmsub_round_ps<const ROUNDING: i32>(
8993 a: __m512,
8994 k: __mmask16,
8995 b: __m512,
8996 c: __m512,
8997) -> __m512 {
8998 unsafe {
8999 static_assert_rounding!(ROUNDING);
9000 let r = vfmadd132psround(a, b, simd_neg(c), ROUNDING);
9001 simd_select_bitmask(k, r, a)
9002 }
9003}
9004
9005#[inline]
9016#[target_feature(enable = "avx512f")]
9017#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9018#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9020pub fn _mm512_maskz_fmsub_round_ps<const ROUNDING: i32>(
9021 k: __mmask16,
9022 a: __m512,
9023 b: __m512,
9024 c: __m512,
9025) -> __m512 {
9026 unsafe {
9027 static_assert_rounding!(ROUNDING);
9028 let r = vfmadd132psround(a, b, simd_neg(c), ROUNDING);
9029 simd_select_bitmask(k, r, _mm512_setzero_ps())
9030 }
9031}
9032
9033#[inline]
9044#[target_feature(enable = "avx512f")]
9045#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9046#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9048pub fn _mm512_mask3_fmsub_round_ps<const ROUNDING: i32>(
9049 a: __m512,
9050 b: __m512,
9051 c: __m512,
9052 k: __mmask16,
9053) -> __m512 {
9054 unsafe {
9055 static_assert_rounding!(ROUNDING);
9056 let r = vfmadd132psround(a, b, simd_neg(c), ROUNDING);
9057 simd_select_bitmask(k, r, c)
9058 }
9059}
9060
9061#[inline]
9072#[target_feature(enable = "avx512f")]
9073#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9074#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9076pub fn _mm512_fmsub_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
9077 unsafe {
9078 static_assert_rounding!(ROUNDING);
9079 vfmadd132pdround(a, b, simd_neg(c), ROUNDING)
9080 }
9081}
9082
9083#[inline]
9094#[target_feature(enable = "avx512f")]
9095#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9096#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9098pub fn _mm512_mask_fmsub_round_pd<const ROUNDING: i32>(
9099 a: __m512d,
9100 k: __mmask8,
9101 b: __m512d,
9102 c: __m512d,
9103) -> __m512d {
9104 unsafe {
9105 static_assert_rounding!(ROUNDING);
9106 let r = vfmadd132pdround(a, b, simd_neg(c), ROUNDING);
9107 simd_select_bitmask(k, r, a)
9108 }
9109}
9110
9111#[inline]
9122#[target_feature(enable = "avx512f")]
9123#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9124#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9126pub fn _mm512_maskz_fmsub_round_pd<const ROUNDING: i32>(
9127 k: __mmask8,
9128 a: __m512d,
9129 b: __m512d,
9130 c: __m512d,
9131) -> __m512d {
9132 unsafe {
9133 static_assert_rounding!(ROUNDING);
9134 let r = vfmadd132pdround(a, b, simd_neg(c), ROUNDING);
9135 simd_select_bitmask(k, r, _mm512_setzero_pd())
9136 }
9137}
9138
9139#[inline]
9150#[target_feature(enable = "avx512f")]
9151#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9152#[cfg_attr(test, assert_instr(vfmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9154pub fn _mm512_mask3_fmsub_round_pd<const ROUNDING: i32>(
9155 a: __m512d,
9156 b: __m512d,
9157 c: __m512d,
9158 k: __mmask8,
9159) -> __m512d {
9160 unsafe {
9161 static_assert_rounding!(ROUNDING);
9162 let r = vfmadd132pdround(a, b, simd_neg(c), ROUNDING);
9163 simd_select_bitmask(k, r, c)
9164 }
9165}
9166
9167#[inline]
9178#[target_feature(enable = "avx512f")]
9179#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9180#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9182pub fn _mm512_fmaddsub_round_ps<const ROUNDING: i32>(a: __m512, b: __m512, c: __m512) -> __m512 {
9183 unsafe {
9184 static_assert_rounding!(ROUNDING);
9185 vfmaddsubpsround(a, b, c, ROUNDING)
9186 }
9187}
9188
9189#[inline]
9200#[target_feature(enable = "avx512f")]
9201#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9202#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9204pub fn _mm512_mask_fmaddsub_round_ps<const ROUNDING: i32>(
9205 a: __m512,
9206 k: __mmask16,
9207 b: __m512,
9208 c: __m512,
9209) -> __m512 {
9210 unsafe {
9211 static_assert_rounding!(ROUNDING);
9212 simd_select_bitmask(k, vfmaddsubpsround(a, b, c, ROUNDING), a)
9213 }
9214}
9215
9216#[inline]
9227#[target_feature(enable = "avx512f")]
9228#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9229#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9231pub fn _mm512_maskz_fmaddsub_round_ps<const ROUNDING: i32>(
9232 k: __mmask16,
9233 a: __m512,
9234 b: __m512,
9235 c: __m512,
9236) -> __m512 {
9237 unsafe {
9238 static_assert_rounding!(ROUNDING);
9239 simd_select_bitmask(k, vfmaddsubpsround(a, b, c, ROUNDING), _mm512_setzero_ps())
9240 }
9241}
9242
9243#[inline]
9254#[target_feature(enable = "avx512f")]
9255#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9256#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9258pub fn _mm512_mask3_fmaddsub_round_ps<const ROUNDING: i32>(
9259 a: __m512,
9260 b: __m512,
9261 c: __m512,
9262 k: __mmask16,
9263) -> __m512 {
9264 unsafe {
9265 static_assert_rounding!(ROUNDING);
9266 simd_select_bitmask(k, vfmaddsubpsround(a, b, c, ROUNDING), c)
9267 }
9268}
9269
9270#[inline]
9281#[target_feature(enable = "avx512f")]
9282#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9283#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9285pub fn _mm512_fmaddsub_round_pd<const ROUNDING: i32>(
9286 a: __m512d,
9287 b: __m512d,
9288 c: __m512d,
9289) -> __m512d {
9290 unsafe {
9291 static_assert_rounding!(ROUNDING);
9292 vfmaddsubpdround(a, b, c, ROUNDING)
9293 }
9294}
9295
9296#[inline]
9307#[target_feature(enable = "avx512f")]
9308#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9309#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9311pub fn _mm512_mask_fmaddsub_round_pd<const ROUNDING: i32>(
9312 a: __m512d,
9313 k: __mmask8,
9314 b: __m512d,
9315 c: __m512d,
9316) -> __m512d {
9317 unsafe {
9318 static_assert_rounding!(ROUNDING);
9319 simd_select_bitmask(k, vfmaddsubpdround(a, b, c, ROUNDING), a)
9320 }
9321}
9322
9323#[inline]
9334#[target_feature(enable = "avx512f")]
9335#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9336#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9338pub fn _mm512_maskz_fmaddsub_round_pd<const ROUNDING: i32>(
9339 k: __mmask8,
9340 a: __m512d,
9341 b: __m512d,
9342 c: __m512d,
9343) -> __m512d {
9344 unsafe {
9345 static_assert_rounding!(ROUNDING);
9346 simd_select_bitmask(k, vfmaddsubpdround(a, b, c, ROUNDING), _mm512_setzero_pd())
9347 }
9348}
9349
9350#[inline]
9361#[target_feature(enable = "avx512f")]
9362#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9363#[cfg_attr(test, assert_instr(vfmaddsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9365pub fn _mm512_mask3_fmaddsub_round_pd<const ROUNDING: i32>(
9366 a: __m512d,
9367 b: __m512d,
9368 c: __m512d,
9369 k: __mmask8,
9370) -> __m512d {
9371 unsafe {
9372 static_assert_rounding!(ROUNDING);
9373 simd_select_bitmask(k, vfmaddsubpdround(a, b, c, ROUNDING), c)
9374 }
9375}
9376
9377#[inline]
9388#[target_feature(enable = "avx512f")]
9389#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9390#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9392pub fn _mm512_fmsubadd_round_ps<const ROUNDING: i32>(a: __m512, b: __m512, c: __m512) -> __m512 {
9393 unsafe {
9394 static_assert_rounding!(ROUNDING);
9395 vfmaddsubpsround(a, b, simd_neg(c), ROUNDING)
9396 }
9397}
9398
9399#[inline]
9410#[target_feature(enable = "avx512f")]
9411#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9412#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9414pub fn _mm512_mask_fmsubadd_round_ps<const ROUNDING: i32>(
9415 a: __m512,
9416 k: __mmask16,
9417 b: __m512,
9418 c: __m512,
9419) -> __m512 {
9420 unsafe {
9421 static_assert_rounding!(ROUNDING);
9422 let r = vfmaddsubpsround(a, b, simd_neg(c), ROUNDING);
9423 simd_select_bitmask(k, r, a)
9424 }
9425}
9426
9427#[inline]
9438#[target_feature(enable = "avx512f")]
9439#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9440#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9442pub fn _mm512_maskz_fmsubadd_round_ps<const ROUNDING: i32>(
9443 k: __mmask16,
9444 a: __m512,
9445 b: __m512,
9446 c: __m512,
9447) -> __m512 {
9448 unsafe {
9449 static_assert_rounding!(ROUNDING);
9450 let r = vfmaddsubpsround(a, b, simd_neg(c), ROUNDING);
9451 simd_select_bitmask(k, r, _mm512_setzero_ps())
9452 }
9453}
9454
9455#[inline]
9466#[target_feature(enable = "avx512f")]
9467#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9468#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9470pub fn _mm512_mask3_fmsubadd_round_ps<const ROUNDING: i32>(
9471 a: __m512,
9472 b: __m512,
9473 c: __m512,
9474 k: __mmask16,
9475) -> __m512 {
9476 unsafe {
9477 static_assert_rounding!(ROUNDING);
9478 let r = vfmaddsubpsround(a, b, simd_neg(c), ROUNDING);
9479 simd_select_bitmask(k, r, c)
9480 }
9481}
9482
9483#[inline]
9494#[target_feature(enable = "avx512f")]
9495#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9496#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9498pub fn _mm512_fmsubadd_round_pd<const ROUNDING: i32>(
9499 a: __m512d,
9500 b: __m512d,
9501 c: __m512d,
9502) -> __m512d {
9503 unsafe {
9504 static_assert_rounding!(ROUNDING);
9505 vfmaddsubpdround(a, b, simd_neg(c), ROUNDING)
9506 }
9507}
9508
9509#[inline]
9520#[target_feature(enable = "avx512f")]
9521#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9522#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9524pub fn _mm512_mask_fmsubadd_round_pd<const ROUNDING: i32>(
9525 a: __m512d,
9526 k: __mmask8,
9527 b: __m512d,
9528 c: __m512d,
9529) -> __m512d {
9530 unsafe {
9531 static_assert_rounding!(ROUNDING);
9532 let r = vfmaddsubpdround(a, b, simd_neg(c), ROUNDING);
9533 simd_select_bitmask(k, r, a)
9534 }
9535}
9536
9537#[inline]
9548#[target_feature(enable = "avx512f")]
9549#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9550#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9552pub fn _mm512_maskz_fmsubadd_round_pd<const ROUNDING: i32>(
9553 k: __mmask8,
9554 a: __m512d,
9555 b: __m512d,
9556 c: __m512d,
9557) -> __m512d {
9558 unsafe {
9559 static_assert_rounding!(ROUNDING);
9560 let r = vfmaddsubpdround(a, b, simd_neg(c), ROUNDING);
9561 simd_select_bitmask(k, r, _mm512_setzero_pd())
9562 }
9563}
9564
9565#[inline]
9576#[target_feature(enable = "avx512f")]
9577#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9578#[cfg_attr(test, assert_instr(vfmsubadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9580pub fn _mm512_mask3_fmsubadd_round_pd<const ROUNDING: i32>(
9581 a: __m512d,
9582 b: __m512d,
9583 c: __m512d,
9584 k: __mmask8,
9585) -> __m512d {
9586 unsafe {
9587 static_assert_rounding!(ROUNDING);
9588 let r = vfmaddsubpdround(a, b, simd_neg(c), ROUNDING);
9589 simd_select_bitmask(k, r, c)
9590 }
9591}
9592
9593#[inline]
9604#[target_feature(enable = "avx512f")]
9605#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9606#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9608pub fn _mm512_fnmadd_round_ps<const ROUNDING: i32>(a: __m512, b: __m512, c: __m512) -> __m512 {
9609 unsafe {
9610 static_assert_rounding!(ROUNDING);
9611 vfmadd132psround(simd_neg(a), b, c, ROUNDING)
9612 }
9613}
9614
9615#[inline]
9626#[target_feature(enable = "avx512f")]
9627#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9628#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9630pub fn _mm512_mask_fnmadd_round_ps<const ROUNDING: i32>(
9631 a: __m512,
9632 k: __mmask16,
9633 b: __m512,
9634 c: __m512,
9635) -> __m512 {
9636 unsafe {
9637 static_assert_rounding!(ROUNDING);
9638 let r = vfmadd132psround(simd_neg(a), b, c, ROUNDING);
9639 simd_select_bitmask(k, r, a)
9640 }
9641}
9642
9643#[inline]
9654#[target_feature(enable = "avx512f")]
9655#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9656#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9658pub fn _mm512_maskz_fnmadd_round_ps<const ROUNDING: i32>(
9659 k: __mmask16,
9660 a: __m512,
9661 b: __m512,
9662 c: __m512,
9663) -> __m512 {
9664 unsafe {
9665 static_assert_rounding!(ROUNDING);
9666 let r = vfmadd132psround(simd_neg(a), b, c, ROUNDING);
9667 simd_select_bitmask(k, r, _mm512_setzero_ps())
9668 }
9669}
9670
9671#[inline]
9682#[target_feature(enable = "avx512f")]
9683#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9684#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9686pub fn _mm512_mask3_fnmadd_round_ps<const ROUNDING: i32>(
9687 a: __m512,
9688 b: __m512,
9689 c: __m512,
9690 k: __mmask16,
9691) -> __m512 {
9692 unsafe {
9693 static_assert_rounding!(ROUNDING);
9694 let r = vfmadd132psround(simd_neg(a), b, c, ROUNDING);
9695 simd_select_bitmask(k, r, c)
9696 }
9697}
9698
9699#[inline]
9710#[target_feature(enable = "avx512f")]
9711#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9712#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9714pub fn _mm512_fnmadd_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
9715 unsafe {
9716 static_assert_rounding!(ROUNDING);
9717 vfmadd132pdround(simd_neg(a), b, c, ROUNDING)
9718 }
9719}
9720
9721#[inline]
9732#[target_feature(enable = "avx512f")]
9733#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9734#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9736pub fn _mm512_mask_fnmadd_round_pd<const ROUNDING: i32>(
9737 a: __m512d,
9738 k: __mmask8,
9739 b: __m512d,
9740 c: __m512d,
9741) -> __m512d {
9742 unsafe {
9743 static_assert_rounding!(ROUNDING);
9744 let r = vfmadd132pdround(simd_neg(a), b, c, ROUNDING);
9745 simd_select_bitmask(k, r, a)
9746 }
9747}
9748
9749#[inline]
9760#[target_feature(enable = "avx512f")]
9761#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9762#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9764pub fn _mm512_maskz_fnmadd_round_pd<const ROUNDING: i32>(
9765 k: __mmask8,
9766 a: __m512d,
9767 b: __m512d,
9768 c: __m512d,
9769) -> __m512d {
9770 unsafe {
9771 static_assert_rounding!(ROUNDING);
9772 let r = vfmadd132pdround(simd_neg(a), b, c, ROUNDING);
9773 simd_select_bitmask(k, r, _mm512_setzero_pd())
9774 }
9775}
9776
9777#[inline]
9788#[target_feature(enable = "avx512f")]
9789#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9790#[cfg_attr(test, assert_instr(vfnmadd, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9792pub fn _mm512_mask3_fnmadd_round_pd<const ROUNDING: i32>(
9793 a: __m512d,
9794 b: __m512d,
9795 c: __m512d,
9796 k: __mmask8,
9797) -> __m512d {
9798 unsafe {
9799 static_assert_rounding!(ROUNDING);
9800 let r = vfmadd132pdround(simd_neg(a), b, c, ROUNDING);
9801 simd_select_bitmask(k, r, c)
9802 }
9803}
9804
9805#[inline]
9816#[target_feature(enable = "avx512f")]
9817#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9818#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9820pub fn _mm512_fnmsub_round_ps<const ROUNDING: i32>(a: __m512, b: __m512, c: __m512) -> __m512 {
9821 unsafe {
9822 static_assert_rounding!(ROUNDING);
9823 vfmadd132psround(simd_neg(a), b, simd_neg(c), ROUNDING)
9824 }
9825}
9826
9827#[inline]
9838#[target_feature(enable = "avx512f")]
9839#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9840#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9842pub fn _mm512_mask_fnmsub_round_ps<const ROUNDING: i32>(
9843 a: __m512,
9844 k: __mmask16,
9845 b: __m512,
9846 c: __m512,
9847) -> __m512 {
9848 unsafe {
9849 static_assert_rounding!(ROUNDING);
9850 let r = vfmadd132psround(simd_neg(a), b, simd_neg(c), ROUNDING);
9851 simd_select_bitmask(k, r, a)
9852 }
9853}
9854
9855#[inline]
9866#[target_feature(enable = "avx512f")]
9867#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9868#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9870pub fn _mm512_maskz_fnmsub_round_ps<const ROUNDING: i32>(
9871 k: __mmask16,
9872 a: __m512,
9873 b: __m512,
9874 c: __m512,
9875) -> __m512 {
9876 unsafe {
9877 static_assert_rounding!(ROUNDING);
9878 let r = vfmadd132psround(simd_neg(a), b, simd_neg(c), ROUNDING);
9879 simd_select_bitmask(k, r, _mm512_setzero_ps())
9880 }
9881}
9882
9883#[inline]
9894#[target_feature(enable = "avx512f")]
9895#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9896#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9898pub fn _mm512_mask3_fnmsub_round_ps<const ROUNDING: i32>(
9899 a: __m512,
9900 b: __m512,
9901 c: __m512,
9902 k: __mmask16,
9903) -> __m512 {
9904 unsafe {
9905 static_assert_rounding!(ROUNDING);
9906 let r = vfmadd132psround(simd_neg(a), b, simd_neg(c), ROUNDING);
9907 simd_select_bitmask(k, r, c)
9908 }
9909}
9910
9911#[inline]
9922#[target_feature(enable = "avx512f")]
9923#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9924#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(3)]
9926pub fn _mm512_fnmsub_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d, c: __m512d) -> __m512d {
9927 unsafe {
9928 static_assert_rounding!(ROUNDING);
9929 vfmadd132pdround(simd_neg(a), b, simd_neg(c), ROUNDING)
9930 }
9931}
9932
9933#[inline]
9944#[target_feature(enable = "avx512f")]
9945#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9946#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9948pub fn _mm512_mask_fnmsub_round_pd<const ROUNDING: i32>(
9949 a: __m512d,
9950 k: __mmask8,
9951 b: __m512d,
9952 c: __m512d,
9953) -> __m512d {
9954 unsafe {
9955 static_assert_rounding!(ROUNDING);
9956 let r = vfmadd132pdround(simd_neg(a), b, simd_neg(c), ROUNDING);
9957 simd_select_bitmask(k, r, a)
9958 }
9959}
9960
9961#[inline]
9972#[target_feature(enable = "avx512f")]
9973#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
9974#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
9976pub fn _mm512_maskz_fnmsub_round_pd<const ROUNDING: i32>(
9977 k: __mmask8,
9978 a: __m512d,
9979 b: __m512d,
9980 c: __m512d,
9981) -> __m512d {
9982 unsafe {
9983 static_assert_rounding!(ROUNDING);
9984 let r = vfmadd132pdround(simd_neg(a), b, simd_neg(c), ROUNDING);
9985 simd_select_bitmask(k, r, _mm512_setzero_pd())
9986 }
9987}
9988
9989#[inline]
10000#[target_feature(enable = "avx512f")]
10001#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10002#[cfg_attr(test, assert_instr(vfnmsub, ROUNDING = 8))] #[rustc_legacy_const_generics(4)]
10004pub fn _mm512_mask3_fnmsub_round_pd<const ROUNDING: i32>(
10005 a: __m512d,
10006 b: __m512d,
10007 c: __m512d,
10008 k: __mmask8,
10009) -> __m512d {
10010 unsafe {
10011 static_assert_rounding!(ROUNDING);
10012 let r = vfmadd132pdround(simd_neg(a), b, simd_neg(c), ROUNDING);
10013 simd_select_bitmask(k, r, c)
10014 }
10015}
10016
10017#[inline]
10022#[target_feature(enable = "avx512f")]
10023#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10024#[cfg_attr(test, assert_instr(vmaxps, SAE = 8))]
10025#[rustc_legacy_const_generics(2)]
10026pub fn _mm512_max_round_ps<const SAE: i32>(a: __m512, b: __m512) -> __m512 {
10027 unsafe {
10028 static_assert_sae!(SAE);
10029 let a = a.as_f32x16();
10030 let b = b.as_f32x16();
10031 let r = vmaxps(a, b, SAE);
10032 transmute(r)
10033 }
10034}
10035
10036#[inline]
10041#[target_feature(enable = "avx512f")]
10042#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10043#[cfg_attr(test, assert_instr(vmaxps, SAE = 8))]
10044#[rustc_legacy_const_generics(4)]
10045pub fn _mm512_mask_max_round_ps<const SAE: i32>(
10046 src: __m512,
10047 k: __mmask16,
10048 a: __m512,
10049 b: __m512,
10050) -> __m512 {
10051 unsafe {
10052 static_assert_sae!(SAE);
10053 let a = a.as_f32x16();
10054 let b = b.as_f32x16();
10055 let r = vmaxps(a, b, SAE);
10056 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
10057 }
10058}
10059
10060#[inline]
10065#[target_feature(enable = "avx512f")]
10066#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10067#[cfg_attr(test, assert_instr(vmaxps, SAE = 8))]
10068#[rustc_legacy_const_generics(3)]
10069pub fn _mm512_maskz_max_round_ps<const SAE: i32>(k: __mmask16, a: __m512, b: __m512) -> __m512 {
10070 unsafe {
10071 static_assert_sae!(SAE);
10072 let a = a.as_f32x16();
10073 let b = b.as_f32x16();
10074 let r = vmaxps(a, b, SAE);
10075 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
10076 }
10077}
10078
10079#[inline]
10084#[target_feature(enable = "avx512f")]
10085#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10086#[cfg_attr(test, assert_instr(vmaxpd, SAE = 8))]
10087#[rustc_legacy_const_generics(2)]
10088pub fn _mm512_max_round_pd<const SAE: i32>(a: __m512d, b: __m512d) -> __m512d {
10089 unsafe {
10090 static_assert_sae!(SAE);
10091 let a = a.as_f64x8();
10092 let b = b.as_f64x8();
10093 let r = vmaxpd(a, b, SAE);
10094 transmute(r)
10095 }
10096}
10097
10098#[inline]
10103#[target_feature(enable = "avx512f")]
10104#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10105#[cfg_attr(test, assert_instr(vmaxpd, SAE = 8))]
10106#[rustc_legacy_const_generics(4)]
10107pub fn _mm512_mask_max_round_pd<const SAE: i32>(
10108 src: __m512d,
10109 k: __mmask8,
10110 a: __m512d,
10111 b: __m512d,
10112) -> __m512d {
10113 unsafe {
10114 static_assert_sae!(SAE);
10115 let a = a.as_f64x8();
10116 let b = b.as_f64x8();
10117 let r = vmaxpd(a, b, SAE);
10118 transmute(simd_select_bitmask(k, r, src.as_f64x8()))
10119 }
10120}
10121
10122#[inline]
10127#[target_feature(enable = "avx512f")]
10128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10129#[cfg_attr(test, assert_instr(vmaxpd, SAE = 8))]
10130#[rustc_legacy_const_generics(3)]
10131pub fn _mm512_maskz_max_round_pd<const SAE: i32>(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
10132 unsafe {
10133 static_assert_sae!(SAE);
10134 let a = a.as_f64x8();
10135 let b = b.as_f64x8();
10136 let r = vmaxpd(a, b, SAE);
10137 transmute(simd_select_bitmask(k, r, f64x8::ZERO))
10138 }
10139}
10140
10141#[inline]
10146#[target_feature(enable = "avx512f")]
10147#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10148#[cfg_attr(test, assert_instr(vminps, SAE = 8))]
10149#[rustc_legacy_const_generics(2)]
10150pub fn _mm512_min_round_ps<const SAE: i32>(a: __m512, b: __m512) -> __m512 {
10151 unsafe {
10152 static_assert_sae!(SAE);
10153 let a = a.as_f32x16();
10154 let b = b.as_f32x16();
10155 let r = vminps(a, b, SAE);
10156 transmute(r)
10157 }
10158}
10159
10160#[inline]
10165#[target_feature(enable = "avx512f")]
10166#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10167#[cfg_attr(test, assert_instr(vminps, SAE = 8))]
10168#[rustc_legacy_const_generics(4)]
10169pub fn _mm512_mask_min_round_ps<const SAE: i32>(
10170 src: __m512,
10171 k: __mmask16,
10172 a: __m512,
10173 b: __m512,
10174) -> __m512 {
10175 unsafe {
10176 static_assert_sae!(SAE);
10177 let a = a.as_f32x16();
10178 let b = b.as_f32x16();
10179 let r = vminps(a, b, SAE);
10180 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
10181 }
10182}
10183
10184#[inline]
10189#[target_feature(enable = "avx512f")]
10190#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10191#[cfg_attr(test, assert_instr(vminps, SAE = 8))]
10192#[rustc_legacy_const_generics(3)]
10193pub fn _mm512_maskz_min_round_ps<const SAE: i32>(k: __mmask16, a: __m512, b: __m512) -> __m512 {
10194 unsafe {
10195 static_assert_sae!(SAE);
10196 let a = a.as_f32x16();
10197 let b = b.as_f32x16();
10198 let r = vminps(a, b, SAE);
10199 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
10200 }
10201}
10202
10203#[inline]
10208#[target_feature(enable = "avx512f")]
10209#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10210#[cfg_attr(test, assert_instr(vminpd, SAE = 8))]
10211#[rustc_legacy_const_generics(2)]
10212pub fn _mm512_min_round_pd<const SAE: i32>(a: __m512d, b: __m512d) -> __m512d {
10213 unsafe {
10214 static_assert_sae!(SAE);
10215 let a = a.as_f64x8();
10216 let b = b.as_f64x8();
10217 let r = vminpd(a, b, SAE);
10218 transmute(r)
10219 }
10220}
10221
10222#[inline]
10227#[target_feature(enable = "avx512f")]
10228#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10229#[cfg_attr(test, assert_instr(vminpd, SAE = 8))]
10230#[rustc_legacy_const_generics(4)]
10231pub fn _mm512_mask_min_round_pd<const SAE: i32>(
10232 src: __m512d,
10233 k: __mmask8,
10234 a: __m512d,
10235 b: __m512d,
10236) -> __m512d {
10237 unsafe {
10238 static_assert_sae!(SAE);
10239 let a = a.as_f64x8();
10240 let b = b.as_f64x8();
10241 let r = vminpd(a, b, SAE);
10242 transmute(simd_select_bitmask(k, r, src.as_f64x8()))
10243 }
10244}
10245
10246#[inline]
10251#[target_feature(enable = "avx512f")]
10252#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10253#[cfg_attr(test, assert_instr(vminpd, SAE = 8))]
10254#[rustc_legacy_const_generics(3)]
10255pub fn _mm512_maskz_min_round_pd<const SAE: i32>(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
10256 unsafe {
10257 static_assert_sae!(SAE);
10258 let a = a.as_f64x8();
10259 let b = b.as_f64x8();
10260 let r = vminpd(a, b, SAE);
10261 transmute(simd_select_bitmask(k, r, f64x8::ZERO))
10262 }
10263}
10264
10265#[inline]
10270#[target_feature(enable = "avx512f")]
10271#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10272#[cfg_attr(test, assert_instr(vgetexpps, SAE = 8))]
10273#[rustc_legacy_const_generics(1)]
10274pub fn _mm512_getexp_round_ps<const SAE: i32>(a: __m512) -> __m512 {
10275 unsafe {
10276 static_assert_sae!(SAE);
10277 let a = a.as_f32x16();
10278 let r = vgetexpps(a, f32x16::ZERO, 0b11111111_11111111, SAE);
10279 transmute(r)
10280 }
10281}
10282
10283#[inline]
10288#[target_feature(enable = "avx512f")]
10289#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10290#[cfg_attr(test, assert_instr(vgetexpps, SAE = 8))]
10291#[rustc_legacy_const_generics(3)]
10292pub fn _mm512_mask_getexp_round_ps<const SAE: i32>(src: __m512, k: __mmask16, a: __m512) -> __m512 {
10293 unsafe {
10294 static_assert_sae!(SAE);
10295 let a = a.as_f32x16();
10296 let src = src.as_f32x16();
10297 let r = vgetexpps(a, src, k, SAE);
10298 transmute(r)
10299 }
10300}
10301
10302#[inline]
10307#[target_feature(enable = "avx512f")]
10308#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10309#[cfg_attr(test, assert_instr(vgetexpps, SAE = 8))]
10310#[rustc_legacy_const_generics(2)]
10311pub fn _mm512_maskz_getexp_round_ps<const SAE: i32>(k: __mmask16, a: __m512) -> __m512 {
10312 unsafe {
10313 static_assert_sae!(SAE);
10314 let a = a.as_f32x16();
10315 let r = vgetexpps(a, f32x16::ZERO, k, SAE);
10316 transmute(r)
10317 }
10318}
10319
10320#[inline]
10325#[target_feature(enable = "avx512f")]
10326#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10327#[cfg_attr(test, assert_instr(vgetexppd, SAE = 8))]
10328#[rustc_legacy_const_generics(1)]
10329pub fn _mm512_getexp_round_pd<const SAE: i32>(a: __m512d) -> __m512d {
10330 unsafe {
10331 static_assert_sae!(SAE);
10332 let a = a.as_f64x8();
10333 let r = vgetexppd(a, f64x8::ZERO, 0b11111111, SAE);
10334 transmute(r)
10335 }
10336}
10337
10338#[inline]
10343#[target_feature(enable = "avx512f")]
10344#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10345#[cfg_attr(test, assert_instr(vgetexppd, SAE = 8))]
10346#[rustc_legacy_const_generics(3)]
10347pub fn _mm512_mask_getexp_round_pd<const SAE: i32>(
10348 src: __m512d,
10349 k: __mmask8,
10350 a: __m512d,
10351) -> __m512d {
10352 unsafe {
10353 static_assert_sae!(SAE);
10354 let a = a.as_f64x8();
10355 let src = src.as_f64x8();
10356 let r = vgetexppd(a, src, k, SAE);
10357 transmute(r)
10358 }
10359}
10360
10361#[inline]
10366#[target_feature(enable = "avx512f")]
10367#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10368#[cfg_attr(test, assert_instr(vgetexppd, SAE = 8))]
10369#[rustc_legacy_const_generics(2)]
10370pub fn _mm512_maskz_getexp_round_pd<const SAE: i32>(k: __mmask8, a: __m512d) -> __m512d {
10371 unsafe {
10372 static_assert_sae!(SAE);
10373 let a = a.as_f64x8();
10374 let r = vgetexppd(a, f64x8::ZERO, k, SAE);
10375 transmute(r)
10376 }
10377}
10378
10379#[inline]
10390#[target_feature(enable = "avx512f")]
10391#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10392#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0, SAE = 8))]
10393#[rustc_legacy_const_generics(1, 2)]
10394pub fn _mm512_roundscale_round_ps<const IMM8: i32, const SAE: i32>(a: __m512) -> __m512 {
10395 unsafe {
10396 static_assert_uimm_bits!(IMM8, 8);
10397 static_assert_mantissas_sae!(SAE);
10398 let a = a.as_f32x16();
10399 let r = vrndscaleps(a, IMM8, f32x16::ZERO, 0b11111111_11111111, SAE);
10400 transmute(r)
10401 }
10402}
10403
10404#[inline]
10415#[target_feature(enable = "avx512f")]
10416#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10417#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0, SAE = 8))]
10418#[rustc_legacy_const_generics(3, 4)]
10419pub fn _mm512_mask_roundscale_round_ps<const IMM8: i32, const SAE: i32>(
10420 src: __m512,
10421 k: __mmask16,
10422 a: __m512,
10423) -> __m512 {
10424 unsafe {
10425 static_assert_uimm_bits!(IMM8, 8);
10426 static_assert_mantissas_sae!(SAE);
10427 let a = a.as_f32x16();
10428 let src = src.as_f32x16();
10429 let r = vrndscaleps(a, IMM8, src, k, SAE);
10430 transmute(r)
10431 }
10432}
10433
10434#[inline]
10445#[target_feature(enable = "avx512f")]
10446#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10447#[cfg_attr(test, assert_instr(vrndscaleps, IMM8 = 0, SAE = 8))]
10448#[rustc_legacy_const_generics(2, 3)]
10449pub fn _mm512_maskz_roundscale_round_ps<const IMM8: i32, const SAE: i32>(
10450 k: __mmask16,
10451 a: __m512,
10452) -> __m512 {
10453 unsafe {
10454 static_assert_uimm_bits!(IMM8, 8);
10455 static_assert_mantissas_sae!(SAE);
10456 let a = a.as_f32x16();
10457 let r = vrndscaleps(a, IMM8, f32x16::ZERO, k, SAE);
10458 transmute(r)
10459 }
10460}
10461
10462#[inline]
10473#[target_feature(enable = "avx512f")]
10474#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10475#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0, SAE = 8))]
10476#[rustc_legacy_const_generics(1, 2)]
10477pub fn _mm512_roundscale_round_pd<const IMM8: i32, const SAE: i32>(a: __m512d) -> __m512d {
10478 unsafe {
10479 static_assert_uimm_bits!(IMM8, 8);
10480 static_assert_mantissas_sae!(SAE);
10481 let a = a.as_f64x8();
10482 let r = vrndscalepd(a, IMM8, f64x8::ZERO, 0b11111111, SAE);
10483 transmute(r)
10484 }
10485}
10486
10487#[inline]
10498#[target_feature(enable = "avx512f")]
10499#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10500#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0, SAE = 8))]
10501#[rustc_legacy_const_generics(3, 4)]
10502pub fn _mm512_mask_roundscale_round_pd<const IMM8: i32, const SAE: i32>(
10503 src: __m512d,
10504 k: __mmask8,
10505 a: __m512d,
10506) -> __m512d {
10507 unsafe {
10508 static_assert_uimm_bits!(IMM8, 8);
10509 static_assert_mantissas_sae!(SAE);
10510 let a = a.as_f64x8();
10511 let src = src.as_f64x8();
10512 let r = vrndscalepd(a, IMM8, src, k, SAE);
10513 transmute(r)
10514 }
10515}
10516
10517#[inline]
10528#[target_feature(enable = "avx512f")]
10529#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10530#[cfg_attr(test, assert_instr(vrndscalepd, IMM8 = 0, SAE = 8))]
10531#[rustc_legacy_const_generics(2, 3)]
10532pub fn _mm512_maskz_roundscale_round_pd<const IMM8: i32, const SAE: i32>(
10533 k: __mmask8,
10534 a: __m512d,
10535) -> __m512d {
10536 unsafe {
10537 static_assert_uimm_bits!(IMM8, 8);
10538 static_assert_mantissas_sae!(SAE);
10539 let a = a.as_f64x8();
10540 let r = vrndscalepd(a, IMM8, f64x8::ZERO, k, SAE);
10541 transmute(r)
10542 }
10543}
10544
10545#[inline]
10556#[target_feature(enable = "avx512f")]
10557#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10558#[cfg_attr(test, assert_instr(vscalefps, ROUNDING = 8))]
10559#[rustc_legacy_const_generics(2)]
10560pub fn _mm512_scalef_round_ps<const ROUNDING: i32>(a: __m512, b: __m512) -> __m512 {
10561 unsafe {
10562 static_assert_rounding!(ROUNDING);
10563 let a = a.as_f32x16();
10564 let b = b.as_f32x16();
10565 let r = vscalefps(a, b, f32x16::ZERO, 0b11111111_11111111, ROUNDING);
10566 transmute(r)
10567 }
10568}
10569
10570#[inline]
10581#[target_feature(enable = "avx512f")]
10582#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10583#[cfg_attr(test, assert_instr(vscalefps, ROUNDING = 8))]
10584#[rustc_legacy_const_generics(4)]
10585pub fn _mm512_mask_scalef_round_ps<const ROUNDING: i32>(
10586 src: __m512,
10587 k: __mmask16,
10588 a: __m512,
10589 b: __m512,
10590) -> __m512 {
10591 unsafe {
10592 static_assert_rounding!(ROUNDING);
10593 let a = a.as_f32x16();
10594 let b = b.as_f32x16();
10595 let src = src.as_f32x16();
10596 let r = vscalefps(a, b, src, k, ROUNDING);
10597 transmute(r)
10598 }
10599}
10600
10601#[inline]
10612#[target_feature(enable = "avx512f")]
10613#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10614#[cfg_attr(test, assert_instr(vscalefps, ROUNDING = 8))]
10615#[rustc_legacy_const_generics(3)]
10616pub fn _mm512_maskz_scalef_round_ps<const ROUNDING: i32>(
10617 k: __mmask16,
10618 a: __m512,
10619 b: __m512,
10620) -> __m512 {
10621 unsafe {
10622 static_assert_rounding!(ROUNDING);
10623 let a = a.as_f32x16();
10624 let b = b.as_f32x16();
10625 let r = vscalefps(a, b, f32x16::ZERO, k, ROUNDING);
10626 transmute(r)
10627 }
10628}
10629
10630#[inline]
10641#[target_feature(enable = "avx512f")]
10642#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10643#[cfg_attr(test, assert_instr(vscalefpd, ROUNDING = 8))]
10644#[rustc_legacy_const_generics(2)]
10645pub fn _mm512_scalef_round_pd<const ROUNDING: i32>(a: __m512d, b: __m512d) -> __m512d {
10646 unsafe {
10647 static_assert_rounding!(ROUNDING);
10648 let a = a.as_f64x8();
10649 let b = b.as_f64x8();
10650 let r = vscalefpd(a, b, f64x8::ZERO, 0b11111111, ROUNDING);
10651 transmute(r)
10652 }
10653}
10654
10655#[inline]
10666#[target_feature(enable = "avx512f")]
10667#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10668#[cfg_attr(test, assert_instr(vscalefpd, ROUNDING = 8))]
10669#[rustc_legacy_const_generics(4)]
10670pub fn _mm512_mask_scalef_round_pd<const ROUNDING: i32>(
10671 src: __m512d,
10672 k: __mmask8,
10673 a: __m512d,
10674 b: __m512d,
10675) -> __m512d {
10676 unsafe {
10677 static_assert_rounding!(ROUNDING);
10678 let a = a.as_f64x8();
10679 let b = b.as_f64x8();
10680 let src = src.as_f64x8();
10681 let r = vscalefpd(a, b, src, k, ROUNDING);
10682 transmute(r)
10683 }
10684}
10685
10686#[inline]
10697#[target_feature(enable = "avx512f")]
10698#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10699#[cfg_attr(test, assert_instr(vscalefpd, ROUNDING = 8))]
10700#[rustc_legacy_const_generics(3)]
10701pub fn _mm512_maskz_scalef_round_pd<const ROUNDING: i32>(
10702 k: __mmask8,
10703 a: __m512d,
10704 b: __m512d,
10705) -> __m512d {
10706 unsafe {
10707 static_assert_rounding!(ROUNDING);
10708 let a = a.as_f64x8();
10709 let b = b.as_f64x8();
10710 let r = vscalefpd(a, b, f64x8::ZERO, k, ROUNDING);
10711 transmute(r)
10712 }
10713}
10714
10715#[inline]
10720#[target_feature(enable = "avx512f")]
10721#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10722#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0, SAE = 8))]
10723#[rustc_legacy_const_generics(3, 4)]
10724pub fn _mm512_fixupimm_round_ps<const IMM8: i32, const SAE: i32>(
10725 a: __m512,
10726 b: __m512,
10727 c: __m512i,
10728) -> __m512 {
10729 unsafe {
10730 static_assert_uimm_bits!(IMM8, 8);
10731 static_assert_mantissas_sae!(SAE);
10732 let a = a.as_f32x16();
10733 let b = b.as_f32x16();
10734 let c = c.as_i32x16();
10735 let r = vfixupimmps(a, b, c, IMM8, 0b11111111_11111111, SAE);
10736 transmute(r)
10737 }
10738}
10739
10740#[inline]
10745#[target_feature(enable = "avx512f")]
10746#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10747#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0, SAE = 8))]
10748#[rustc_legacy_const_generics(4, 5)]
10749pub fn _mm512_mask_fixupimm_round_ps<const IMM8: i32, const SAE: i32>(
10750 a: __m512,
10751 k: __mmask16,
10752 b: __m512,
10753 c: __m512i,
10754) -> __m512 {
10755 unsafe {
10756 static_assert_uimm_bits!(IMM8, 8);
10757 static_assert_mantissas_sae!(SAE);
10758 let a = a.as_f32x16();
10759 let b = b.as_f32x16();
10760 let c = c.as_i32x16();
10761 let r = vfixupimmps(a, b, c, IMM8, k, SAE);
10762 transmute(r)
10763 }
10764}
10765
10766#[inline]
10771#[target_feature(enable = "avx512f")]
10772#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10773#[cfg_attr(test, assert_instr(vfixupimmps, IMM8 = 0, SAE = 8))]
10774#[rustc_legacy_const_generics(4, 5)]
10775pub fn _mm512_maskz_fixupimm_round_ps<const IMM8: i32, const SAE: i32>(
10776 k: __mmask16,
10777 a: __m512,
10778 b: __m512,
10779 c: __m512i,
10780) -> __m512 {
10781 unsafe {
10782 static_assert_uimm_bits!(IMM8, 8);
10783 static_assert_mantissas_sae!(SAE);
10784 let a = a.as_f32x16();
10785 let b = b.as_f32x16();
10786 let c = c.as_i32x16();
10787 let r = vfixupimmpsz(a, b, c, IMM8, k, SAE);
10788 transmute(r)
10789 }
10790}
10791
10792#[inline]
10797#[target_feature(enable = "avx512f")]
10798#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10799#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0, SAE = 8))]
10800#[rustc_legacy_const_generics(3, 4)]
10801pub fn _mm512_fixupimm_round_pd<const IMM8: i32, const SAE: i32>(
10802 a: __m512d,
10803 b: __m512d,
10804 c: __m512i,
10805) -> __m512d {
10806 unsafe {
10807 static_assert_uimm_bits!(IMM8, 8);
10808 static_assert_mantissas_sae!(SAE);
10809 let a = a.as_f64x8();
10810 let b = b.as_f64x8();
10811 let c = c.as_i64x8();
10812 let r = vfixupimmpd(a, b, c, IMM8, 0b11111111, SAE);
10813 transmute(r)
10814 }
10815}
10816
10817#[inline]
10822#[target_feature(enable = "avx512f")]
10823#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10824#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0, SAE = 8))]
10825#[rustc_legacy_const_generics(4, 5)]
10826pub fn _mm512_mask_fixupimm_round_pd<const IMM8: i32, const SAE: i32>(
10827 a: __m512d,
10828 k: __mmask8,
10829 b: __m512d,
10830 c: __m512i,
10831) -> __m512d {
10832 unsafe {
10833 static_assert_uimm_bits!(IMM8, 8);
10834 static_assert_mantissas_sae!(SAE);
10835 let a = a.as_f64x8();
10836 let b = b.as_f64x8();
10837 let c = c.as_i64x8();
10838 let r = vfixupimmpd(a, b, c, IMM8, k, SAE);
10839 transmute(r)
10840 }
10841}
10842
10843#[inline]
10848#[target_feature(enable = "avx512f")]
10849#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10850#[cfg_attr(test, assert_instr(vfixupimmpd, IMM8 = 0, SAE = 8))]
10851#[rustc_legacy_const_generics(4, 5)]
10852pub fn _mm512_maskz_fixupimm_round_pd<const IMM8: i32, const SAE: i32>(
10853 k: __mmask8,
10854 a: __m512d,
10855 b: __m512d,
10856 c: __m512i,
10857) -> __m512d {
10858 unsafe {
10859 static_assert_uimm_bits!(IMM8, 8);
10860 static_assert_mantissas_sae!(SAE);
10861 let a = a.as_f64x8();
10862 let b = b.as_f64x8();
10863 let c = c.as_i64x8();
10864 let r = vfixupimmpdz(a, b, c, IMM8, k, SAE);
10865 transmute(r)
10866 }
10867}
10868
10869#[inline]
10883#[target_feature(enable = "avx512f")]
10884#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10885#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0, SAE = 4))]
10886#[rustc_legacy_const_generics(1, 2, 3)]
10887pub fn _mm512_getmant_round_ps<
10888 const NORM: _MM_MANTISSA_NORM_ENUM,
10889 const SIGN: _MM_MANTISSA_SIGN_ENUM,
10890 const SAE: i32,
10891>(
10892 a: __m512,
10893) -> __m512 {
10894 unsafe {
10895 static_assert_uimm_bits!(NORM, 4);
10896 static_assert_uimm_bits!(SIGN, 2);
10897 static_assert_mantissas_sae!(SAE);
10898 let a = a.as_f32x16();
10899 let r = vgetmantps(a, SIGN << 2 | NORM, f32x16::ZERO, 0b11111111_11111111, SAE);
10900 transmute(r)
10901 }
10902}
10903
10904#[inline]
10918#[target_feature(enable = "avx512f")]
10919#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10920#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0, SAE = 4))]
10921#[rustc_legacy_const_generics(3, 4, 5)]
10922pub fn _mm512_mask_getmant_round_ps<
10923 const NORM: _MM_MANTISSA_NORM_ENUM,
10924 const SIGN: _MM_MANTISSA_SIGN_ENUM,
10925 const SAE: i32,
10926>(
10927 src: __m512,
10928 k: __mmask16,
10929 a: __m512,
10930) -> __m512 {
10931 unsafe {
10932 static_assert_uimm_bits!(NORM, 4);
10933 static_assert_uimm_bits!(SIGN, 2);
10934 static_assert_mantissas_sae!(SAE);
10935 let a = a.as_f32x16();
10936 let src = src.as_f32x16();
10937 let r = vgetmantps(a, SIGN << 2 | NORM, src, k, SAE);
10938 transmute(r)
10939 }
10940}
10941
10942#[inline]
10956#[target_feature(enable = "avx512f")]
10957#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10958#[cfg_attr(test, assert_instr(vgetmantps, NORM = 0, SIGN = 0, SAE = 4))]
10959#[rustc_legacy_const_generics(2, 3, 4)]
10960pub fn _mm512_maskz_getmant_round_ps<
10961 const NORM: _MM_MANTISSA_NORM_ENUM,
10962 const SIGN: _MM_MANTISSA_SIGN_ENUM,
10963 const SAE: i32,
10964>(
10965 k: __mmask16,
10966 a: __m512,
10967) -> __m512 {
10968 unsafe {
10969 static_assert_uimm_bits!(NORM, 4);
10970 static_assert_uimm_bits!(SIGN, 2);
10971 static_assert_mantissas_sae!(SAE);
10972 let a = a.as_f32x16();
10973 let r = vgetmantps(a, SIGN << 2 | NORM, f32x16::ZERO, k, SAE);
10974 transmute(r)
10975 }
10976}
10977
10978#[inline]
10992#[target_feature(enable = "avx512f")]
10993#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
10994#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0, SAE = 4))]
10995#[rustc_legacy_const_generics(1, 2, 3)]
10996pub fn _mm512_getmant_round_pd<
10997 const NORM: _MM_MANTISSA_NORM_ENUM,
10998 const SIGN: _MM_MANTISSA_SIGN_ENUM,
10999 const SAE: i32,
11000>(
11001 a: __m512d,
11002) -> __m512d {
11003 unsafe {
11004 static_assert_uimm_bits!(NORM, 4);
11005 static_assert_uimm_bits!(SIGN, 2);
11006 static_assert_mantissas_sae!(SAE);
11007 let a = a.as_f64x8();
11008 let r = vgetmantpd(a, SIGN << 2 | NORM, f64x8::ZERO, 0b11111111, SAE);
11009 transmute(r)
11010 }
11011}
11012
11013#[inline]
11027#[target_feature(enable = "avx512f")]
11028#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11029#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0, SAE = 4))]
11030#[rustc_legacy_const_generics(3, 4, 5)]
11031pub fn _mm512_mask_getmant_round_pd<
11032 const NORM: _MM_MANTISSA_NORM_ENUM,
11033 const SIGN: _MM_MANTISSA_SIGN_ENUM,
11034 const SAE: i32,
11035>(
11036 src: __m512d,
11037 k: __mmask8,
11038 a: __m512d,
11039) -> __m512d {
11040 unsafe {
11041 static_assert_uimm_bits!(NORM, 4);
11042 static_assert_uimm_bits!(SIGN, 2);
11043 static_assert_mantissas_sae!(SAE);
11044 let a = a.as_f64x8();
11045 let src = src.as_f64x8();
11046 let r = vgetmantpd(a, SIGN << 2 | NORM, src, k, SAE);
11047 transmute(r)
11048 }
11049}
11050
11051#[inline]
11065#[target_feature(enable = "avx512f")]
11066#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11067#[cfg_attr(test, assert_instr(vgetmantpd, NORM = 0, SIGN = 0, SAE = 4))]
11068#[rustc_legacy_const_generics(2, 3, 4)]
11069pub fn _mm512_maskz_getmant_round_pd<
11070 const NORM: _MM_MANTISSA_NORM_ENUM,
11071 const SIGN: _MM_MANTISSA_SIGN_ENUM,
11072 const SAE: i32,
11073>(
11074 k: __mmask8,
11075 a: __m512d,
11076) -> __m512d {
11077 unsafe {
11078 static_assert_uimm_bits!(NORM, 4);
11079 static_assert_uimm_bits!(SIGN, 2);
11080 static_assert_mantissas_sae!(SAE);
11081 let a = a.as_f64x8();
11082 let r = vgetmantpd(a, SIGN << 2 | NORM, f64x8::ZERO, k, SAE);
11083 transmute(r)
11084 }
11085}
11086
11087#[inline]
11091#[target_feature(enable = "avx512f")]
11092#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11093#[cfg_attr(test, assert_instr(vcvtps2dq))]
11094pub fn _mm512_cvtps_epi32(a: __m512) -> __m512i {
11095 unsafe {
11096 transmute(vcvtps2dq(
11097 a.as_f32x16(),
11098 i32x16::ZERO,
11099 0b11111111_11111111,
11100 _MM_FROUND_CUR_DIRECTION,
11101 ))
11102 }
11103}
11104
11105#[inline]
11109#[target_feature(enable = "avx512f")]
11110#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11111#[cfg_attr(test, assert_instr(vcvtps2dq))]
11112pub fn _mm512_mask_cvtps_epi32(src: __m512i, k: __mmask16, a: __m512) -> __m512i {
11113 unsafe {
11114 transmute(vcvtps2dq(
11115 a.as_f32x16(),
11116 src.as_i32x16(),
11117 k,
11118 _MM_FROUND_CUR_DIRECTION,
11119 ))
11120 }
11121}
11122
11123#[inline]
11127#[target_feature(enable = "avx512f")]
11128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11129#[cfg_attr(test, assert_instr(vcvtps2dq))]
11130pub fn _mm512_maskz_cvtps_epi32(k: __mmask16, a: __m512) -> __m512i {
11131 unsafe {
11132 transmute(vcvtps2dq(
11133 a.as_f32x16(),
11134 i32x16::ZERO,
11135 k,
11136 _MM_FROUND_CUR_DIRECTION,
11137 ))
11138 }
11139}
11140
11141#[inline]
11145#[target_feature(enable = "avx512f,avx512vl")]
11146#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11147#[cfg_attr(test, assert_instr(vcvtps2dq))]
11148pub fn _mm256_mask_cvtps_epi32(src: __m256i, k: __mmask8, a: __m256) -> __m256i {
11149 unsafe {
11150 let convert = _mm256_cvtps_epi32(a);
11151 transmute(simd_select_bitmask(k, convert.as_i32x8(), src.as_i32x8()))
11152 }
11153}
11154
11155#[inline]
11159#[target_feature(enable = "avx512f,avx512vl")]
11160#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11161#[cfg_attr(test, assert_instr(vcvtps2dq))]
11162pub fn _mm256_maskz_cvtps_epi32(k: __mmask8, a: __m256) -> __m256i {
11163 unsafe {
11164 let convert = _mm256_cvtps_epi32(a);
11165 transmute(simd_select_bitmask(k, convert.as_i32x8(), i32x8::ZERO))
11166 }
11167}
11168
11169#[inline]
11173#[target_feature(enable = "avx512f,avx512vl")]
11174#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11175#[cfg_attr(test, assert_instr(vcvtps2dq))]
11176pub fn _mm_mask_cvtps_epi32(src: __m128i, k: __mmask8, a: __m128) -> __m128i {
11177 unsafe {
11178 let convert = _mm_cvtps_epi32(a);
11179 transmute(simd_select_bitmask(k, convert.as_i32x4(), src.as_i32x4()))
11180 }
11181}
11182
11183#[inline]
11187#[target_feature(enable = "avx512f,avx512vl")]
11188#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11189#[cfg_attr(test, assert_instr(vcvtps2dq))]
11190pub fn _mm_maskz_cvtps_epi32(k: __mmask8, a: __m128) -> __m128i {
11191 unsafe {
11192 let convert = _mm_cvtps_epi32(a);
11193 transmute(simd_select_bitmask(k, convert.as_i32x4(), i32x4::ZERO))
11194 }
11195}
11196
11197#[inline]
11201#[target_feature(enable = "avx512f")]
11202#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11203#[cfg_attr(test, assert_instr(vcvtps2udq))]
11204pub fn _mm512_cvtps_epu32(a: __m512) -> __m512i {
11205 unsafe {
11206 transmute(vcvtps2udq(
11207 a.as_f32x16(),
11208 u32x16::ZERO,
11209 0b11111111_11111111,
11210 _MM_FROUND_CUR_DIRECTION,
11211 ))
11212 }
11213}
11214
11215#[inline]
11219#[target_feature(enable = "avx512f")]
11220#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11221#[cfg_attr(test, assert_instr(vcvtps2udq))]
11222pub fn _mm512_mask_cvtps_epu32(src: __m512i, k: __mmask16, a: __m512) -> __m512i {
11223 unsafe {
11224 transmute(vcvtps2udq(
11225 a.as_f32x16(),
11226 src.as_u32x16(),
11227 k,
11228 _MM_FROUND_CUR_DIRECTION,
11229 ))
11230 }
11231}
11232
11233#[inline]
11237#[target_feature(enable = "avx512f")]
11238#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11239#[cfg_attr(test, assert_instr(vcvtps2udq))]
11240pub fn _mm512_maskz_cvtps_epu32(k: __mmask16, a: __m512) -> __m512i {
11241 unsafe {
11242 transmute(vcvtps2udq(
11243 a.as_f32x16(),
11244 u32x16::ZERO,
11245 k,
11246 _MM_FROUND_CUR_DIRECTION,
11247 ))
11248 }
11249}
11250
11251#[inline]
11255#[target_feature(enable = "avx512f,avx512vl")]
11256#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11257#[cfg_attr(test, assert_instr(vcvtps2udq))]
11258pub fn _mm256_cvtps_epu32(a: __m256) -> __m256i {
11259 unsafe { transmute(vcvtps2udq256(a.as_f32x8(), u32x8::ZERO, 0b11111111)) }
11260}
11261
11262#[inline]
11266#[target_feature(enable = "avx512f,avx512vl")]
11267#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11268#[cfg_attr(test, assert_instr(vcvtps2udq))]
11269pub fn _mm256_mask_cvtps_epu32(src: __m256i, k: __mmask8, a: __m256) -> __m256i {
11270 unsafe { transmute(vcvtps2udq256(a.as_f32x8(), src.as_u32x8(), k)) }
11271}
11272
11273#[inline]
11277#[target_feature(enable = "avx512f,avx512vl")]
11278#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11279#[cfg_attr(test, assert_instr(vcvtps2udq))]
11280pub fn _mm256_maskz_cvtps_epu32(k: __mmask8, a: __m256) -> __m256i {
11281 unsafe { transmute(vcvtps2udq256(a.as_f32x8(), u32x8::ZERO, k)) }
11282}
11283
11284#[inline]
11288#[target_feature(enable = "avx512f,avx512vl")]
11289#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11290#[cfg_attr(test, assert_instr(vcvtps2udq))]
11291pub fn _mm_cvtps_epu32(a: __m128) -> __m128i {
11292 unsafe { transmute(vcvtps2udq128(a.as_f32x4(), u32x4::ZERO, 0b11111111)) }
11293}
11294
11295#[inline]
11299#[target_feature(enable = "avx512f,avx512vl")]
11300#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11301#[cfg_attr(test, assert_instr(vcvtps2udq))]
11302pub fn _mm_mask_cvtps_epu32(src: __m128i, k: __mmask8, a: __m128) -> __m128i {
11303 unsafe { transmute(vcvtps2udq128(a.as_f32x4(), src.as_u32x4(), k)) }
11304}
11305
11306#[inline]
11310#[target_feature(enable = "avx512f,avx512vl")]
11311#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11312#[cfg_attr(test, assert_instr(vcvtps2udq))]
11313pub fn _mm_maskz_cvtps_epu32(k: __mmask8, a: __m128) -> __m128i {
11314 unsafe { transmute(vcvtps2udq128(a.as_f32x4(), u32x4::ZERO, k)) }
11315}
11316
11317#[inline]
11321#[target_feature(enable = "avx512f")]
11322#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11323#[cfg_attr(test, assert_instr(vcvtps2pd))]
11324pub fn _mm512_cvtps_pd(a: __m256) -> __m512d {
11325 unsafe {
11326 transmute(vcvtps2pd(
11327 a.as_f32x8(),
11328 f64x8::ZERO,
11329 0b11111111,
11330 _MM_FROUND_CUR_DIRECTION,
11331 ))
11332 }
11333}
11334
11335#[inline]
11339#[target_feature(enable = "avx512f")]
11340#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11341#[cfg_attr(test, assert_instr(vcvtps2pd))]
11342pub fn _mm512_mask_cvtps_pd(src: __m512d, k: __mmask8, a: __m256) -> __m512d {
11343 unsafe {
11344 transmute(vcvtps2pd(
11345 a.as_f32x8(),
11346 src.as_f64x8(),
11347 k,
11348 _MM_FROUND_CUR_DIRECTION,
11349 ))
11350 }
11351}
11352
11353#[inline]
11357#[target_feature(enable = "avx512f")]
11358#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11359#[cfg_attr(test, assert_instr(vcvtps2pd))]
11360pub fn _mm512_maskz_cvtps_pd(k: __mmask8, a: __m256) -> __m512d {
11361 unsafe {
11362 transmute(vcvtps2pd(
11363 a.as_f32x8(),
11364 f64x8::ZERO,
11365 k,
11366 _MM_FROUND_CUR_DIRECTION,
11367 ))
11368 }
11369}
11370
11371#[inline]
11375#[target_feature(enable = "avx512f")]
11376#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11377#[cfg_attr(test, assert_instr(vcvtps2pd))]
11378pub fn _mm512_cvtpslo_pd(v2: __m512) -> __m512d {
11379 unsafe {
11380 transmute(vcvtps2pd(
11381 _mm512_castps512_ps256(v2).as_f32x8(),
11382 f64x8::ZERO,
11383 0b11111111,
11384 _MM_FROUND_CUR_DIRECTION,
11385 ))
11386 }
11387}
11388
11389#[inline]
11393#[target_feature(enable = "avx512f")]
11394#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11395#[cfg_attr(test, assert_instr(vcvtps2pd))]
11396pub fn _mm512_mask_cvtpslo_pd(src: __m512d, k: __mmask8, v2: __m512) -> __m512d {
11397 unsafe {
11398 transmute(vcvtps2pd(
11399 _mm512_castps512_ps256(v2).as_f32x8(),
11400 src.as_f64x8(),
11401 k,
11402 _MM_FROUND_CUR_DIRECTION,
11403 ))
11404 }
11405}
11406
11407#[inline]
11411#[target_feature(enable = "avx512f")]
11412#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11413#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11414pub fn _mm512_cvtpd_ps(a: __m512d) -> __m256 {
11415 unsafe {
11416 transmute(vcvtpd2ps(
11417 a.as_f64x8(),
11418 f32x8::ZERO,
11419 0b11111111,
11420 _MM_FROUND_CUR_DIRECTION,
11421 ))
11422 }
11423}
11424
11425#[inline]
11429#[target_feature(enable = "avx512f")]
11430#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11431#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11432pub fn _mm512_mask_cvtpd_ps(src: __m256, k: __mmask8, a: __m512d) -> __m256 {
11433 unsafe {
11434 transmute(vcvtpd2ps(
11435 a.as_f64x8(),
11436 src.as_f32x8(),
11437 k,
11438 _MM_FROUND_CUR_DIRECTION,
11439 ))
11440 }
11441}
11442
11443#[inline]
11447#[target_feature(enable = "avx512f")]
11448#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11449#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11450pub fn _mm512_maskz_cvtpd_ps(k: __mmask8, a: __m512d) -> __m256 {
11451 unsafe {
11452 transmute(vcvtpd2ps(
11453 a.as_f64x8(),
11454 f32x8::ZERO,
11455 k,
11456 _MM_FROUND_CUR_DIRECTION,
11457 ))
11458 }
11459}
11460
11461#[inline]
11465#[target_feature(enable = "avx512f,avx512vl")]
11466#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11467#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11468pub fn _mm256_mask_cvtpd_ps(src: __m128, k: __mmask8, a: __m256d) -> __m128 {
11469 unsafe {
11470 let convert = _mm256_cvtpd_ps(a);
11471 transmute(simd_select_bitmask(k, convert.as_f32x4(), src.as_f32x4()))
11472 }
11473}
11474
11475#[inline]
11479#[target_feature(enable = "avx512f,avx512vl")]
11480#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11481#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11482pub fn _mm256_maskz_cvtpd_ps(k: __mmask8, a: __m256d) -> __m128 {
11483 unsafe {
11484 let convert = _mm256_cvtpd_ps(a);
11485 transmute(simd_select_bitmask(k, convert.as_f32x4(), f32x4::ZERO))
11486 }
11487}
11488
11489#[inline]
11493#[target_feature(enable = "avx512f,avx512vl")]
11494#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11495#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11496pub fn _mm_mask_cvtpd_ps(src: __m128, k: __mmask8, a: __m128d) -> __m128 {
11497 unsafe { vcvtpd2ps128(a.as_f64x2(), src.as_f32x4(), k).as_m128() }
11498}
11499
11500#[inline]
11504#[target_feature(enable = "avx512f,avx512vl")]
11505#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11506#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11507pub fn _mm_maskz_cvtpd_ps(k: __mmask8, a: __m128d) -> __m128 {
11508 unsafe {
11509 let convert = _mm_cvtpd_ps(a);
11510 transmute(simd_select_bitmask(k, convert.as_f32x4(), f32x4::ZERO))
11511 }
11512}
11513
11514#[inline]
11518#[target_feature(enable = "avx512f")]
11519#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11520#[cfg_attr(test, assert_instr(vcvtpd2dq))]
11521pub fn _mm512_cvtpd_epi32(a: __m512d) -> __m256i {
11522 unsafe {
11523 transmute(vcvtpd2dq(
11524 a.as_f64x8(),
11525 i32x8::ZERO,
11526 0b11111111,
11527 _MM_FROUND_CUR_DIRECTION,
11528 ))
11529 }
11530}
11531
11532#[inline]
11536#[target_feature(enable = "avx512f")]
11537#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11538#[cfg_attr(test, assert_instr(vcvtpd2dq))]
11539pub fn _mm512_mask_cvtpd_epi32(src: __m256i, k: __mmask8, a: __m512d) -> __m256i {
11540 unsafe {
11541 transmute(vcvtpd2dq(
11542 a.as_f64x8(),
11543 src.as_i32x8(),
11544 k,
11545 _MM_FROUND_CUR_DIRECTION,
11546 ))
11547 }
11548}
11549
11550#[inline]
11554#[target_feature(enable = "avx512f")]
11555#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11556#[cfg_attr(test, assert_instr(vcvtpd2dq))]
11557pub fn _mm512_maskz_cvtpd_epi32(k: __mmask8, a: __m512d) -> __m256i {
11558 unsafe {
11559 transmute(vcvtpd2dq(
11560 a.as_f64x8(),
11561 i32x8::ZERO,
11562 k,
11563 _MM_FROUND_CUR_DIRECTION,
11564 ))
11565 }
11566}
11567
11568#[inline]
11572#[target_feature(enable = "avx512f,avx512vl")]
11573#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11574#[cfg_attr(test, assert_instr(vcvtpd2dq))]
11575pub fn _mm256_mask_cvtpd_epi32(src: __m128i, k: __mmask8, a: __m256d) -> __m128i {
11576 unsafe {
11577 let convert = _mm256_cvtpd_epi32(a);
11578 transmute(simd_select_bitmask(k, convert.as_i32x4(), src.as_i32x4()))
11579 }
11580}
11581
11582#[inline]
11586#[target_feature(enable = "avx512f,avx512vl")]
11587#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11588#[cfg_attr(test, assert_instr(vcvtpd2dq))]
11589pub fn _mm256_maskz_cvtpd_epi32(k: __mmask8, a: __m256d) -> __m128i {
11590 unsafe {
11591 let convert = _mm256_cvtpd_epi32(a);
11592 transmute(simd_select_bitmask(k, convert.as_i32x4(), i32x4::ZERO))
11593 }
11594}
11595
11596#[inline]
11600#[target_feature(enable = "avx512f,avx512vl")]
11601#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11602#[cfg_attr(test, assert_instr(vcvtpd2dq))]
11603pub fn _mm_mask_cvtpd_epi32(src: __m128i, k: __mmask8, a: __m128d) -> __m128i {
11604 unsafe { vcvtpd2dq128(a.as_f64x2(), src.as_i32x4(), k).as_m128i() }
11605}
11606
11607#[inline]
11611#[target_feature(enable = "avx512f,avx512vl")]
11612#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11613#[cfg_attr(test, assert_instr(vcvtpd2dq))]
11614pub fn _mm_maskz_cvtpd_epi32(k: __mmask8, a: __m128d) -> __m128i {
11615 unsafe {
11616 let convert = _mm_cvtpd_epi32(a);
11617 transmute(simd_select_bitmask(k, convert.as_i32x4(), i32x4::ZERO))
11618 }
11619}
11620
11621#[inline]
11625#[target_feature(enable = "avx512f")]
11626#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11627#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11628pub fn _mm512_cvtpd_epu32(a: __m512d) -> __m256i {
11629 unsafe {
11630 transmute(vcvtpd2udq(
11631 a.as_f64x8(),
11632 u32x8::ZERO,
11633 0b11111111,
11634 _MM_FROUND_CUR_DIRECTION,
11635 ))
11636 }
11637}
11638
11639#[inline]
11643#[target_feature(enable = "avx512f")]
11644#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11645#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11646pub fn _mm512_mask_cvtpd_epu32(src: __m256i, k: __mmask8, a: __m512d) -> __m256i {
11647 unsafe {
11648 transmute(vcvtpd2udq(
11649 a.as_f64x8(),
11650 src.as_u32x8(),
11651 k,
11652 _MM_FROUND_CUR_DIRECTION,
11653 ))
11654 }
11655}
11656
11657#[inline]
11661#[target_feature(enable = "avx512f")]
11662#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11663#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11664pub fn _mm512_maskz_cvtpd_epu32(k: __mmask8, a: __m512d) -> __m256i {
11665 unsafe {
11666 transmute(vcvtpd2udq(
11667 a.as_f64x8(),
11668 u32x8::ZERO,
11669 k,
11670 _MM_FROUND_CUR_DIRECTION,
11671 ))
11672 }
11673}
11674
11675#[inline]
11679#[target_feature(enable = "avx512f,avx512vl")]
11680#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11681#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11682pub fn _mm256_cvtpd_epu32(a: __m256d) -> __m128i {
11683 unsafe { transmute(vcvtpd2udq256(a.as_f64x4(), u32x4::ZERO, 0b11111111)) }
11684}
11685
11686#[inline]
11690#[target_feature(enable = "avx512f,avx512vl")]
11691#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11692#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11693pub fn _mm256_mask_cvtpd_epu32(src: __m128i, k: __mmask8, a: __m256d) -> __m128i {
11694 unsafe { transmute(vcvtpd2udq256(a.as_f64x4(), src.as_u32x4(), k)) }
11695}
11696
11697#[inline]
11701#[target_feature(enable = "avx512f,avx512vl")]
11702#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11703#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11704pub fn _mm256_maskz_cvtpd_epu32(k: __mmask8, a: __m256d) -> __m128i {
11705 unsafe { transmute(vcvtpd2udq256(a.as_f64x4(), u32x4::ZERO, k)) }
11706}
11707
11708#[inline]
11712#[target_feature(enable = "avx512f,avx512vl")]
11713#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11714#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11715pub fn _mm_cvtpd_epu32(a: __m128d) -> __m128i {
11716 unsafe { transmute(vcvtpd2udq128(a.as_f64x2(), u32x4::ZERO, 0b11111111)) }
11717}
11718
11719#[inline]
11723#[target_feature(enable = "avx512f,avx512vl")]
11724#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11725#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11726pub fn _mm_mask_cvtpd_epu32(src: __m128i, k: __mmask8, a: __m128d) -> __m128i {
11727 unsafe { transmute(vcvtpd2udq128(a.as_f64x2(), src.as_u32x4(), k)) }
11728}
11729
11730#[inline]
11734#[target_feature(enable = "avx512f,avx512vl")]
11735#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11736#[cfg_attr(test, assert_instr(vcvtpd2udq))]
11737pub fn _mm_maskz_cvtpd_epu32(k: __mmask8, a: __m128d) -> __m128i {
11738 unsafe { transmute(vcvtpd2udq128(a.as_f64x2(), u32x4::ZERO, k)) }
11739}
11740
11741#[inline]
11745#[target_feature(enable = "avx512f")]
11746#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11747#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11748pub fn _mm512_cvtpd_pslo(v2: __m512d) -> __m512 {
11749 unsafe {
11750 let r: f32x8 = vcvtpd2ps(
11751 v2.as_f64x8(),
11752 f32x8::ZERO,
11753 0b11111111,
11754 _MM_FROUND_CUR_DIRECTION,
11755 );
11756 simd_shuffle!(
11757 r,
11758 f32x8::ZERO,
11759 [0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8],
11760 )
11761 }
11762}
11763
11764#[inline]
11768#[target_feature(enable = "avx512f")]
11769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11770#[cfg_attr(test, assert_instr(vcvtpd2ps))]
11771pub fn _mm512_mask_cvtpd_pslo(src: __m512, k: __mmask8, v2: __m512d) -> __m512 {
11772 unsafe {
11773 let r: f32x8 = vcvtpd2ps(
11774 v2.as_f64x8(),
11775 _mm512_castps512_ps256(src).as_f32x8(),
11776 k,
11777 _MM_FROUND_CUR_DIRECTION,
11778 );
11779 simd_shuffle!(
11780 r,
11781 f32x8::ZERO,
11782 [0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8],
11783 )
11784 }
11785}
11786
11787#[inline]
11791#[target_feature(enable = "avx512f")]
11792#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11793#[cfg_attr(test, assert_instr(vpmovsxbd))]
11794#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11795pub const fn _mm512_cvtepi8_epi32(a: __m128i) -> __m512i {
11796 unsafe {
11797 let a = a.as_i8x16();
11798 transmute::<i32x16, _>(simd_cast(a))
11799 }
11800}
11801
11802#[inline]
11806#[target_feature(enable = "avx512f")]
11807#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11808#[cfg_attr(test, assert_instr(vpmovsxbd))]
11809#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11810pub const fn _mm512_mask_cvtepi8_epi32(src: __m512i, k: __mmask16, a: __m128i) -> __m512i {
11811 unsafe {
11812 let convert = _mm512_cvtepi8_epi32(a).as_i32x16();
11813 transmute(simd_select_bitmask(k, convert, src.as_i32x16()))
11814 }
11815}
11816
11817#[inline]
11821#[target_feature(enable = "avx512f")]
11822#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11823#[cfg_attr(test, assert_instr(vpmovsxbd))]
11824#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11825pub const fn _mm512_maskz_cvtepi8_epi32(k: __mmask16, a: __m128i) -> __m512i {
11826 unsafe {
11827 let convert = _mm512_cvtepi8_epi32(a).as_i32x16();
11828 transmute(simd_select_bitmask(k, convert, i32x16::ZERO))
11829 }
11830}
11831
11832#[inline]
11836#[target_feature(enable = "avx512f,avx512vl")]
11837#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11838#[cfg_attr(test, assert_instr(vpmovsxbd))]
11839#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11840pub const fn _mm256_mask_cvtepi8_epi32(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
11841 unsafe {
11842 let convert = _mm256_cvtepi8_epi32(a).as_i32x8();
11843 transmute(simd_select_bitmask(k, convert, src.as_i32x8()))
11844 }
11845}
11846
11847#[inline]
11851#[target_feature(enable = "avx512f,avx512vl")]
11852#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11853#[cfg_attr(test, assert_instr(vpmovsxbd))]
11854#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11855pub const fn _mm256_maskz_cvtepi8_epi32(k: __mmask8, a: __m128i) -> __m256i {
11856 unsafe {
11857 let convert = _mm256_cvtepi8_epi32(a).as_i32x8();
11858 transmute(simd_select_bitmask(k, convert, i32x8::ZERO))
11859 }
11860}
11861
11862#[inline]
11866#[target_feature(enable = "avx512f,avx512vl")]
11867#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11868#[cfg_attr(test, assert_instr(vpmovsxbd))]
11869#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11870pub const fn _mm_mask_cvtepi8_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
11871 unsafe {
11872 let convert = _mm_cvtepi8_epi32(a).as_i32x4();
11873 transmute(simd_select_bitmask(k, convert, src.as_i32x4()))
11874 }
11875}
11876
11877#[inline]
11881#[target_feature(enable = "avx512f,avx512vl")]
11882#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11883#[cfg_attr(test, assert_instr(vpmovsxbd))]
11884#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11885pub const fn _mm_maskz_cvtepi8_epi32(k: __mmask8, a: __m128i) -> __m128i {
11886 unsafe {
11887 let convert = _mm_cvtepi8_epi32(a).as_i32x4();
11888 transmute(simd_select_bitmask(k, convert, i32x4::ZERO))
11889 }
11890}
11891
11892#[inline]
11896#[target_feature(enable = "avx512f")]
11897#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11898#[cfg_attr(test, assert_instr(vpmovsxbq))]
11899#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11900pub const fn _mm512_cvtepi8_epi64(a: __m128i) -> __m512i {
11901 unsafe {
11902 let a = a.as_i8x16();
11903 let v64: i8x8 = simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7]);
11904 transmute::<i64x8, _>(simd_cast(v64))
11905 }
11906}
11907
11908#[inline]
11912#[target_feature(enable = "avx512f")]
11913#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11914#[cfg_attr(test, assert_instr(vpmovsxbq))]
11915#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11916pub const fn _mm512_mask_cvtepi8_epi64(src: __m512i, k: __mmask8, a: __m128i) -> __m512i {
11917 unsafe {
11918 let convert = _mm512_cvtepi8_epi64(a).as_i64x8();
11919 transmute(simd_select_bitmask(k, convert, src.as_i64x8()))
11920 }
11921}
11922
11923#[inline]
11927#[target_feature(enable = "avx512f")]
11928#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11929#[cfg_attr(test, assert_instr(vpmovsxbq))]
11930#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11931pub const fn _mm512_maskz_cvtepi8_epi64(k: __mmask8, a: __m128i) -> __m512i {
11932 unsafe {
11933 let convert = _mm512_cvtepi8_epi64(a).as_i64x8();
11934 transmute(simd_select_bitmask(k, convert, i64x8::ZERO))
11935 }
11936}
11937
11938#[inline]
11942#[target_feature(enable = "avx512f,avx512vl")]
11943#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11944#[cfg_attr(test, assert_instr(vpmovsxbq))]
11945#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11946pub const fn _mm256_mask_cvtepi8_epi64(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
11947 unsafe {
11948 let convert = _mm256_cvtepi8_epi64(a).as_i64x4();
11949 transmute(simd_select_bitmask(k, convert, src.as_i64x4()))
11950 }
11951}
11952
11953#[inline]
11957#[target_feature(enable = "avx512f,avx512vl")]
11958#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11959#[cfg_attr(test, assert_instr(vpmovsxbq))]
11960#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11961pub const fn _mm256_maskz_cvtepi8_epi64(k: __mmask8, a: __m128i) -> __m256i {
11962 unsafe {
11963 let convert = _mm256_cvtepi8_epi64(a).as_i64x4();
11964 transmute(simd_select_bitmask(k, convert, i64x4::ZERO))
11965 }
11966}
11967
11968#[inline]
11972#[target_feature(enable = "avx512f,avx512vl")]
11973#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11974#[cfg_attr(test, assert_instr(vpmovsxbq))]
11975#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11976pub const fn _mm_mask_cvtepi8_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
11977 unsafe {
11978 let convert = _mm_cvtepi8_epi64(a).as_i64x2();
11979 transmute(simd_select_bitmask(k, convert, src.as_i64x2()))
11980 }
11981}
11982
11983#[inline]
11987#[target_feature(enable = "avx512f,avx512vl")]
11988#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
11989#[cfg_attr(test, assert_instr(vpmovsxbq))]
11990#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
11991pub const fn _mm_maskz_cvtepi8_epi64(k: __mmask8, a: __m128i) -> __m128i {
11992 unsafe {
11993 let convert = _mm_cvtepi8_epi64(a).as_i64x2();
11994 transmute(simd_select_bitmask(k, convert, i64x2::ZERO))
11995 }
11996}
11997
11998#[inline]
12002#[target_feature(enable = "avx512f")]
12003#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12004#[cfg_attr(test, assert_instr(vpmovzxbd))]
12005#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12006pub const fn _mm512_cvtepu8_epi32(a: __m128i) -> __m512i {
12007 unsafe {
12008 let a = a.as_u8x16();
12009 transmute::<i32x16, _>(simd_cast(a))
12010 }
12011}
12012
12013#[inline]
12017#[target_feature(enable = "avx512f")]
12018#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12019#[cfg_attr(test, assert_instr(vpmovzxbd))]
12020#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12021pub const fn _mm512_mask_cvtepu8_epi32(src: __m512i, k: __mmask16, a: __m128i) -> __m512i {
12022 unsafe {
12023 let convert = _mm512_cvtepu8_epi32(a).as_i32x16();
12024 transmute(simd_select_bitmask(k, convert, src.as_i32x16()))
12025 }
12026}
12027
12028#[inline]
12032#[target_feature(enable = "avx512f")]
12033#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12034#[cfg_attr(test, assert_instr(vpmovzxbd))]
12035#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12036pub const fn _mm512_maskz_cvtepu8_epi32(k: __mmask16, a: __m128i) -> __m512i {
12037 unsafe {
12038 let convert = _mm512_cvtepu8_epi32(a).as_i32x16();
12039 transmute(simd_select_bitmask(k, convert, i32x16::ZERO))
12040 }
12041}
12042
12043#[inline]
12047#[target_feature(enable = "avx512f,avx512vl")]
12048#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12049#[cfg_attr(test, assert_instr(vpmovzxbd))]
12050#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12051pub const fn _mm256_mask_cvtepu8_epi32(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12052 unsafe {
12053 let convert = _mm256_cvtepu8_epi32(a).as_i32x8();
12054 transmute(simd_select_bitmask(k, convert, src.as_i32x8()))
12055 }
12056}
12057
12058#[inline]
12062#[target_feature(enable = "avx512f,avx512vl")]
12063#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12064#[cfg_attr(test, assert_instr(vpmovzxbd))]
12065#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12066pub const fn _mm256_maskz_cvtepu8_epi32(k: __mmask8, a: __m128i) -> __m256i {
12067 unsafe {
12068 let convert = _mm256_cvtepu8_epi32(a).as_i32x8();
12069 transmute(simd_select_bitmask(k, convert, i32x8::ZERO))
12070 }
12071}
12072
12073#[inline]
12077#[target_feature(enable = "avx512f,avx512vl")]
12078#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12079#[cfg_attr(test, assert_instr(vpmovzxbd))]
12080#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12081pub const fn _mm_mask_cvtepu8_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12082 unsafe {
12083 let convert = _mm_cvtepu8_epi32(a).as_i32x4();
12084 transmute(simd_select_bitmask(k, convert, src.as_i32x4()))
12085 }
12086}
12087
12088#[inline]
12092#[target_feature(enable = "avx512f,avx512vl")]
12093#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12094#[cfg_attr(test, assert_instr(vpmovzxbd))]
12095#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12096pub const fn _mm_maskz_cvtepu8_epi32(k: __mmask8, a: __m128i) -> __m128i {
12097 unsafe {
12098 let convert = _mm_cvtepu8_epi32(a).as_i32x4();
12099 transmute(simd_select_bitmask(k, convert, i32x4::ZERO))
12100 }
12101}
12102
12103#[inline]
12107#[target_feature(enable = "avx512f")]
12108#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12109#[cfg_attr(test, assert_instr(vpmovzxbq))]
12110#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12111pub const fn _mm512_cvtepu8_epi64(a: __m128i) -> __m512i {
12112 unsafe {
12113 let a = a.as_u8x16();
12114 let v64: u8x8 = simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7]);
12115 transmute::<i64x8, _>(simd_cast(v64))
12116 }
12117}
12118
12119#[inline]
12123#[target_feature(enable = "avx512f")]
12124#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12125#[cfg_attr(test, assert_instr(vpmovzxbq))]
12126#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12127pub const fn _mm512_mask_cvtepu8_epi64(src: __m512i, k: __mmask8, a: __m128i) -> __m512i {
12128 unsafe {
12129 let convert = _mm512_cvtepu8_epi64(a).as_i64x8();
12130 transmute(simd_select_bitmask(k, convert, src.as_i64x8()))
12131 }
12132}
12133
12134#[inline]
12138#[target_feature(enable = "avx512f")]
12139#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12140#[cfg_attr(test, assert_instr(vpmovzxbq))]
12141#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12142pub const fn _mm512_maskz_cvtepu8_epi64(k: __mmask8, a: __m128i) -> __m512i {
12143 unsafe {
12144 let convert = _mm512_cvtepu8_epi64(a).as_i64x8();
12145 transmute(simd_select_bitmask(k, convert, i64x8::ZERO))
12146 }
12147}
12148
12149#[inline]
12153#[target_feature(enable = "avx512f,avx512vl")]
12154#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12155#[cfg_attr(test, assert_instr(vpmovzxbq))]
12156#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12157pub const fn _mm256_mask_cvtepu8_epi64(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12158 unsafe {
12159 let convert = _mm256_cvtepu8_epi64(a).as_i64x4();
12160 transmute(simd_select_bitmask(k, convert, src.as_i64x4()))
12161 }
12162}
12163
12164#[inline]
12168#[target_feature(enable = "avx512f,avx512vl")]
12169#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12170#[cfg_attr(test, assert_instr(vpmovzxbq))]
12171#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12172pub const fn _mm256_maskz_cvtepu8_epi64(k: __mmask8, a: __m128i) -> __m256i {
12173 unsafe {
12174 let convert = _mm256_cvtepu8_epi64(a).as_i64x4();
12175 transmute(simd_select_bitmask(k, convert, i64x4::ZERO))
12176 }
12177}
12178
12179#[inline]
12183#[target_feature(enable = "avx512f,avx512vl")]
12184#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12185#[cfg_attr(test, assert_instr(vpmovzxbq))]
12186#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12187pub const fn _mm_mask_cvtepu8_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12188 unsafe {
12189 let convert = _mm_cvtepu8_epi64(a).as_i64x2();
12190 transmute(simd_select_bitmask(k, convert, src.as_i64x2()))
12191 }
12192}
12193
12194#[inline]
12198#[target_feature(enable = "avx512f,avx512vl")]
12199#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12200#[cfg_attr(test, assert_instr(vpmovzxbq))]
12201#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12202pub const fn _mm_maskz_cvtepu8_epi64(k: __mmask8, a: __m128i) -> __m128i {
12203 unsafe {
12204 let convert = _mm_cvtepu8_epi64(a).as_i64x2();
12205 transmute(simd_select_bitmask(k, convert, i64x2::ZERO))
12206 }
12207}
12208
12209#[inline]
12213#[target_feature(enable = "avx512f")]
12214#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12215#[cfg_attr(test, assert_instr(vpmovsxwd))]
12216#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12217pub const fn _mm512_cvtepi16_epi32(a: __m256i) -> __m512i {
12218 unsafe {
12219 let a = a.as_i16x16();
12220 transmute::<i32x16, _>(simd_cast(a))
12221 }
12222}
12223
12224#[inline]
12228#[target_feature(enable = "avx512f")]
12229#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12230#[cfg_attr(test, assert_instr(vpmovsxwd))]
12231#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12232pub const fn _mm512_mask_cvtepi16_epi32(src: __m512i, k: __mmask16, a: __m256i) -> __m512i {
12233 unsafe {
12234 let convert = _mm512_cvtepi16_epi32(a).as_i32x16();
12235 transmute(simd_select_bitmask(k, convert, src.as_i32x16()))
12236 }
12237}
12238
12239#[inline]
12243#[target_feature(enable = "avx512f")]
12244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12245#[cfg_attr(test, assert_instr(vpmovsxwd))]
12246#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12247pub const fn _mm512_maskz_cvtepi16_epi32(k: __mmask16, a: __m256i) -> __m512i {
12248 unsafe {
12249 let convert = _mm512_cvtepi16_epi32(a).as_i32x16();
12250 transmute(simd_select_bitmask(k, convert, i32x16::ZERO))
12251 }
12252}
12253
12254#[inline]
12258#[target_feature(enable = "avx512f,avx512vl")]
12259#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12260#[cfg_attr(test, assert_instr(vpmovsxwd))]
12261#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12262pub const fn _mm256_mask_cvtepi16_epi32(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12263 unsafe {
12264 let convert = _mm256_cvtepi16_epi32(a).as_i32x8();
12265 transmute(simd_select_bitmask(k, convert, src.as_i32x8()))
12266 }
12267}
12268
12269#[inline]
12273#[target_feature(enable = "avx512f,avx512vl")]
12274#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12275#[cfg_attr(test, assert_instr(vpmovsxwd))]
12276#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12277pub const fn _mm256_maskz_cvtepi16_epi32(k: __mmask8, a: __m128i) -> __m256i {
12278 unsafe {
12279 let convert = _mm256_cvtepi16_epi32(a).as_i32x8();
12280 transmute(simd_select_bitmask(k, convert, i32x8::ZERO))
12281 }
12282}
12283
12284#[inline]
12288#[target_feature(enable = "avx512f,avx512vl")]
12289#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12290#[cfg_attr(test, assert_instr(vpmovsxwd))]
12291#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12292pub const fn _mm_mask_cvtepi16_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12293 unsafe {
12294 let convert = _mm_cvtepi16_epi32(a).as_i32x4();
12295 transmute(simd_select_bitmask(k, convert, src.as_i32x4()))
12296 }
12297}
12298
12299#[inline]
12303#[target_feature(enable = "avx512f,avx512vl")]
12304#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12305#[cfg_attr(test, assert_instr(vpmovsxwd))]
12306#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12307pub const fn _mm_maskz_cvtepi16_epi32(k: __mmask8, a: __m128i) -> __m128i {
12308 unsafe {
12309 let convert = _mm_cvtepi16_epi32(a).as_i32x4();
12310 transmute(simd_select_bitmask(k, convert, i32x4::ZERO))
12311 }
12312}
12313
12314#[inline]
12318#[target_feature(enable = "avx512f")]
12319#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12320#[cfg_attr(test, assert_instr(vpmovsxwq))]
12321#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12322pub const fn _mm512_cvtepi16_epi64(a: __m128i) -> __m512i {
12323 unsafe {
12324 let a = a.as_i16x8();
12325 transmute::<i64x8, _>(simd_cast(a))
12326 }
12327}
12328
12329#[inline]
12333#[target_feature(enable = "avx512f")]
12334#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12335#[cfg_attr(test, assert_instr(vpmovsxwq))]
12336#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12337pub const fn _mm512_mask_cvtepi16_epi64(src: __m512i, k: __mmask8, a: __m128i) -> __m512i {
12338 unsafe {
12339 let convert = _mm512_cvtepi16_epi64(a).as_i64x8();
12340 transmute(simd_select_bitmask(k, convert, src.as_i64x8()))
12341 }
12342}
12343
12344#[inline]
12348#[target_feature(enable = "avx512f")]
12349#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12350#[cfg_attr(test, assert_instr(vpmovsxwq))]
12351#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12352pub const fn _mm512_maskz_cvtepi16_epi64(k: __mmask8, a: __m128i) -> __m512i {
12353 unsafe {
12354 let convert = _mm512_cvtepi16_epi64(a).as_i64x8();
12355 transmute(simd_select_bitmask(k, convert, i64x8::ZERO))
12356 }
12357}
12358
12359#[inline]
12363#[target_feature(enable = "avx512f,avx512vl")]
12364#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12365#[cfg_attr(test, assert_instr(vpmovsxwq))]
12366#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12367pub const fn _mm256_mask_cvtepi16_epi64(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12368 unsafe {
12369 let convert = _mm256_cvtepi16_epi64(a).as_i64x4();
12370 transmute(simd_select_bitmask(k, convert, src.as_i64x4()))
12371 }
12372}
12373
12374#[inline]
12378#[target_feature(enable = "avx512f,avx512vl")]
12379#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12380#[cfg_attr(test, assert_instr(vpmovsxwq))]
12381#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12382pub const fn _mm256_maskz_cvtepi16_epi64(k: __mmask8, a: __m128i) -> __m256i {
12383 unsafe {
12384 let convert = _mm256_cvtepi16_epi64(a).as_i64x4();
12385 transmute(simd_select_bitmask(k, convert, i64x4::ZERO))
12386 }
12387}
12388
12389#[inline]
12393#[target_feature(enable = "avx512f,avx512vl")]
12394#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12395#[cfg_attr(test, assert_instr(vpmovsxwq))]
12396#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12397pub const fn _mm_mask_cvtepi16_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12398 unsafe {
12399 let convert = _mm_cvtepi16_epi64(a).as_i64x2();
12400 transmute(simd_select_bitmask(k, convert, src.as_i64x2()))
12401 }
12402}
12403
12404#[inline]
12408#[target_feature(enable = "avx512f,avx512vl")]
12409#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12410#[cfg_attr(test, assert_instr(vpmovsxwq))]
12411#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12412pub const fn _mm_maskz_cvtepi16_epi64(k: __mmask8, a: __m128i) -> __m128i {
12413 unsafe {
12414 let convert = _mm_cvtepi16_epi64(a).as_i64x2();
12415 transmute(simd_select_bitmask(k, convert, i64x2::ZERO))
12416 }
12417}
12418
12419#[inline]
12423#[target_feature(enable = "avx512f")]
12424#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12425#[cfg_attr(test, assert_instr(vpmovzxwd))]
12426#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12427pub const fn _mm512_cvtepu16_epi32(a: __m256i) -> __m512i {
12428 unsafe {
12429 let a = a.as_u16x16();
12430 transmute::<i32x16, _>(simd_cast(a))
12431 }
12432}
12433
12434#[inline]
12438#[target_feature(enable = "avx512f")]
12439#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12440#[cfg_attr(test, assert_instr(vpmovzxwd))]
12441#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12442pub const fn _mm512_mask_cvtepu16_epi32(src: __m512i, k: __mmask16, a: __m256i) -> __m512i {
12443 unsafe {
12444 let convert = _mm512_cvtepu16_epi32(a).as_i32x16();
12445 transmute(simd_select_bitmask(k, convert, src.as_i32x16()))
12446 }
12447}
12448
12449#[inline]
12453#[target_feature(enable = "avx512f")]
12454#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12455#[cfg_attr(test, assert_instr(vpmovzxwd))]
12456#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12457pub const fn _mm512_maskz_cvtepu16_epi32(k: __mmask16, a: __m256i) -> __m512i {
12458 unsafe {
12459 let convert = _mm512_cvtepu16_epi32(a).as_i32x16();
12460 transmute(simd_select_bitmask(k, convert, i32x16::ZERO))
12461 }
12462}
12463
12464#[inline]
12468#[target_feature(enable = "avx512f,avx512vl")]
12469#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12470#[cfg_attr(test, assert_instr(vpmovzxwd))]
12471#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12472pub const fn _mm256_mask_cvtepu16_epi32(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12473 unsafe {
12474 let convert = _mm256_cvtepu16_epi32(a).as_i32x8();
12475 transmute(simd_select_bitmask(k, convert, src.as_i32x8()))
12476 }
12477}
12478
12479#[inline]
12483#[target_feature(enable = "avx512f,avx512vl")]
12484#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12485#[cfg_attr(test, assert_instr(vpmovzxwd))]
12486#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12487pub const fn _mm256_maskz_cvtepu16_epi32(k: __mmask8, a: __m128i) -> __m256i {
12488 unsafe {
12489 let convert = _mm256_cvtepu16_epi32(a).as_i32x8();
12490 transmute(simd_select_bitmask(k, convert, i32x8::ZERO))
12491 }
12492}
12493
12494#[inline]
12498#[target_feature(enable = "avx512f,avx512vl")]
12499#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12500#[cfg_attr(test, assert_instr(vpmovzxwd))]
12501#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12502pub const fn _mm_mask_cvtepu16_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12503 unsafe {
12504 let convert = _mm_cvtepu16_epi32(a).as_i32x4();
12505 transmute(simd_select_bitmask(k, convert, src.as_i32x4()))
12506 }
12507}
12508
12509#[inline]
12513#[target_feature(enable = "avx512f,avx512vl")]
12514#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12515#[cfg_attr(test, assert_instr(vpmovzxwd))]
12516#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12517pub const fn _mm_maskz_cvtepu16_epi32(k: __mmask8, a: __m128i) -> __m128i {
12518 unsafe {
12519 let convert = _mm_cvtepu16_epi32(a).as_i32x4();
12520 transmute(simd_select_bitmask(k, convert, i32x4::ZERO))
12521 }
12522}
12523
12524#[inline]
12528#[target_feature(enable = "avx512f")]
12529#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12530#[cfg_attr(test, assert_instr(vpmovzxwq))]
12531#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12532pub const fn _mm512_cvtepu16_epi64(a: __m128i) -> __m512i {
12533 unsafe {
12534 let a = a.as_u16x8();
12535 transmute::<i64x8, _>(simd_cast(a))
12536 }
12537}
12538
12539#[inline]
12543#[target_feature(enable = "avx512f")]
12544#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12545#[cfg_attr(test, assert_instr(vpmovzxwq))]
12546#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12547pub const fn _mm512_mask_cvtepu16_epi64(src: __m512i, k: __mmask8, a: __m128i) -> __m512i {
12548 unsafe {
12549 let convert = _mm512_cvtepu16_epi64(a).as_i64x8();
12550 transmute(simd_select_bitmask(k, convert, src.as_i64x8()))
12551 }
12552}
12553
12554#[inline]
12558#[target_feature(enable = "avx512f")]
12559#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12560#[cfg_attr(test, assert_instr(vpmovzxwq))]
12561#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12562pub const fn _mm512_maskz_cvtepu16_epi64(k: __mmask8, a: __m128i) -> __m512i {
12563 unsafe {
12564 let convert = _mm512_cvtepu16_epi64(a).as_i64x8();
12565 transmute(simd_select_bitmask(k, convert, i64x8::ZERO))
12566 }
12567}
12568
12569#[inline]
12573#[target_feature(enable = "avx512f,avx512vl")]
12574#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12575#[cfg_attr(test, assert_instr(vpmovzxwq))]
12576#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12577pub const fn _mm256_mask_cvtepu16_epi64(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12578 unsafe {
12579 let convert = _mm256_cvtepu16_epi64(a).as_i64x4();
12580 transmute(simd_select_bitmask(k, convert, src.as_i64x4()))
12581 }
12582}
12583
12584#[inline]
12588#[target_feature(enable = "avx512f,avx512vl")]
12589#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12590#[cfg_attr(test, assert_instr(vpmovzxwq))]
12591#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12592pub const fn _mm256_maskz_cvtepu16_epi64(k: __mmask8, a: __m128i) -> __m256i {
12593 unsafe {
12594 let convert = _mm256_cvtepu16_epi64(a).as_i64x4();
12595 transmute(simd_select_bitmask(k, convert, i64x4::ZERO))
12596 }
12597}
12598
12599#[inline]
12603#[target_feature(enable = "avx512f,avx512vl")]
12604#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12605#[cfg_attr(test, assert_instr(vpmovzxwq))]
12606#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12607pub const fn _mm_mask_cvtepu16_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12608 unsafe {
12609 let convert = _mm_cvtepu16_epi64(a).as_i64x2();
12610 transmute(simd_select_bitmask(k, convert, src.as_i64x2()))
12611 }
12612}
12613
12614#[inline]
12618#[target_feature(enable = "avx512f,avx512vl")]
12619#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12620#[cfg_attr(test, assert_instr(vpmovzxwq))]
12621#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12622pub const fn _mm_maskz_cvtepu16_epi64(k: __mmask8, a: __m128i) -> __m128i {
12623 unsafe {
12624 let convert = _mm_cvtepu16_epi64(a).as_i64x2();
12625 transmute(simd_select_bitmask(k, convert, i64x2::ZERO))
12626 }
12627}
12628
12629#[inline]
12633#[target_feature(enable = "avx512f")]
12634#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12635#[cfg_attr(test, assert_instr(vpmovsxdq))]
12636#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12637pub const fn _mm512_cvtepi32_epi64(a: __m256i) -> __m512i {
12638 unsafe {
12639 let a = a.as_i32x8();
12640 transmute::<i64x8, _>(simd_cast(a))
12641 }
12642}
12643
12644#[inline]
12648#[target_feature(enable = "avx512f")]
12649#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12650#[cfg_attr(test, assert_instr(vpmovsxdq))]
12651#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12652pub const fn _mm512_mask_cvtepi32_epi64(src: __m512i, k: __mmask8, a: __m256i) -> __m512i {
12653 unsafe {
12654 let convert = _mm512_cvtepi32_epi64(a).as_i64x8();
12655 transmute(simd_select_bitmask(k, convert, src.as_i64x8()))
12656 }
12657}
12658
12659#[inline]
12663#[target_feature(enable = "avx512f")]
12664#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12665#[cfg_attr(test, assert_instr(vpmovsxdq))]
12666#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12667pub const fn _mm512_maskz_cvtepi32_epi64(k: __mmask8, a: __m256i) -> __m512i {
12668 unsafe {
12669 let convert = _mm512_cvtepi32_epi64(a).as_i64x8();
12670 transmute(simd_select_bitmask(k, convert, i64x8::ZERO))
12671 }
12672}
12673
12674#[inline]
12678#[target_feature(enable = "avx512f,avx512vl")]
12679#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12680#[cfg_attr(test, assert_instr(vpmovsxdq))]
12681#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12682pub const fn _mm256_mask_cvtepi32_epi64(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12683 unsafe {
12684 let convert = _mm256_cvtepi32_epi64(a).as_i64x4();
12685 transmute(simd_select_bitmask(k, convert, src.as_i64x4()))
12686 }
12687}
12688
12689#[inline]
12693#[target_feature(enable = "avx512f,avx512vl")]
12694#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12695#[cfg_attr(test, assert_instr(vpmovsxdq))]
12696#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12697pub const fn _mm256_maskz_cvtepi32_epi64(k: __mmask8, a: __m128i) -> __m256i {
12698 unsafe {
12699 let convert = _mm256_cvtepi32_epi64(a).as_i64x4();
12700 transmute(simd_select_bitmask(k, convert, i64x4::ZERO))
12701 }
12702}
12703
12704#[inline]
12708#[target_feature(enable = "avx512f,avx512vl")]
12709#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12710#[cfg_attr(test, assert_instr(vpmovsxdq))]
12711#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12712pub const fn _mm_mask_cvtepi32_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12713 unsafe {
12714 let convert = _mm_cvtepi32_epi64(a).as_i64x2();
12715 transmute(simd_select_bitmask(k, convert, src.as_i64x2()))
12716 }
12717}
12718
12719#[inline]
12723#[target_feature(enable = "avx512f,avx512vl")]
12724#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12725#[cfg_attr(test, assert_instr(vpmovsxdq))]
12726#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12727pub const fn _mm_maskz_cvtepi32_epi64(k: __mmask8, a: __m128i) -> __m128i {
12728 unsafe {
12729 let convert = _mm_cvtepi32_epi64(a).as_i64x2();
12730 transmute(simd_select_bitmask(k, convert, i64x2::ZERO))
12731 }
12732}
12733
12734#[inline]
12738#[target_feature(enable = "avx512f")]
12739#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12740#[cfg_attr(test, assert_instr(vpmovzxdq))]
12741#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12742pub const fn _mm512_cvtepu32_epi64(a: __m256i) -> __m512i {
12743 unsafe {
12744 let a = a.as_u32x8();
12745 transmute::<i64x8, _>(simd_cast(a))
12746 }
12747}
12748
12749#[inline]
12753#[target_feature(enable = "avx512f")]
12754#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12755#[cfg_attr(test, assert_instr(vpmovzxdq))]
12756#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12757pub const fn _mm512_mask_cvtepu32_epi64(src: __m512i, k: __mmask8, a: __m256i) -> __m512i {
12758 unsafe {
12759 let convert = _mm512_cvtepu32_epi64(a).as_i64x8();
12760 transmute(simd_select_bitmask(k, convert, src.as_i64x8()))
12761 }
12762}
12763
12764#[inline]
12768#[target_feature(enable = "avx512f")]
12769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12770#[cfg_attr(test, assert_instr(vpmovzxdq))]
12771#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12772pub const fn _mm512_maskz_cvtepu32_epi64(k: __mmask8, a: __m256i) -> __m512i {
12773 unsafe {
12774 let convert = _mm512_cvtepu32_epi64(a).as_i64x8();
12775 transmute(simd_select_bitmask(k, convert, i64x8::ZERO))
12776 }
12777}
12778
12779#[inline]
12783#[target_feature(enable = "avx512f,avx512vl")]
12784#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12785#[cfg_attr(test, assert_instr(vpmovzxdq))]
12786#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12787pub const fn _mm256_mask_cvtepu32_epi64(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
12788 unsafe {
12789 let convert = _mm256_cvtepu32_epi64(a).as_i64x4();
12790 transmute(simd_select_bitmask(k, convert, src.as_i64x4()))
12791 }
12792}
12793
12794#[inline]
12798#[target_feature(enable = "avx512f,avx512vl")]
12799#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12800#[cfg_attr(test, assert_instr(vpmovzxdq))]
12801#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12802pub const fn _mm256_maskz_cvtepu32_epi64(k: __mmask8, a: __m128i) -> __m256i {
12803 unsafe {
12804 let convert = _mm256_cvtepu32_epi64(a).as_i64x4();
12805 transmute(simd_select_bitmask(k, convert, i64x4::ZERO))
12806 }
12807}
12808
12809#[inline]
12813#[target_feature(enable = "avx512f,avx512vl")]
12814#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12815#[cfg_attr(test, assert_instr(vpmovzxdq))]
12816#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12817pub const fn _mm_mask_cvtepu32_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
12818 unsafe {
12819 let convert = _mm_cvtepu32_epi64(a).as_i64x2();
12820 transmute(simd_select_bitmask(k, convert, src.as_i64x2()))
12821 }
12822}
12823
12824#[inline]
12828#[target_feature(enable = "avx512f,avx512vl")]
12829#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12830#[cfg_attr(test, assert_instr(vpmovzxdq))]
12831#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12832pub const fn _mm_maskz_cvtepu32_epi64(k: __mmask8, a: __m128i) -> __m128i {
12833 unsafe {
12834 let convert = _mm_cvtepu32_epi64(a).as_i64x2();
12835 transmute(simd_select_bitmask(k, convert, i64x2::ZERO))
12836 }
12837}
12838
12839#[inline]
12843#[target_feature(enable = "avx512f")]
12844#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12845#[cfg_attr(test, assert_instr(vcvtdq2ps))]
12846#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12847pub const fn _mm512_cvtepi32_ps(a: __m512i) -> __m512 {
12848 unsafe {
12849 let a = a.as_i32x16();
12850 transmute::<f32x16, _>(simd_cast(a))
12851 }
12852}
12853
12854#[inline]
12858#[target_feature(enable = "avx512f")]
12859#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12860#[cfg_attr(test, assert_instr(vcvtdq2ps))]
12861#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12862pub const fn _mm512_mask_cvtepi32_ps(src: __m512, k: __mmask16, a: __m512i) -> __m512 {
12863 unsafe {
12864 let convert = _mm512_cvtepi32_ps(a).as_f32x16();
12865 transmute(simd_select_bitmask(k, convert, src.as_f32x16()))
12866 }
12867}
12868
12869#[inline]
12873#[target_feature(enable = "avx512f")]
12874#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12875#[cfg_attr(test, assert_instr(vcvtdq2ps))]
12876#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12877pub const fn _mm512_maskz_cvtepi32_ps(k: __mmask16, a: __m512i) -> __m512 {
12878 unsafe {
12879 let convert = _mm512_cvtepi32_ps(a).as_f32x16();
12880 transmute(simd_select_bitmask(k, convert, f32x16::ZERO))
12881 }
12882}
12883
12884#[inline]
12888#[target_feature(enable = "avx512f,avx512vl")]
12889#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12890#[cfg_attr(test, assert_instr(vcvtdq2ps))]
12891#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12892pub const fn _mm256_mask_cvtepi32_ps(src: __m256, k: __mmask8, a: __m256i) -> __m256 {
12893 unsafe {
12894 let convert = _mm256_cvtepi32_ps(a).as_f32x8();
12895 transmute(simd_select_bitmask(k, convert, src.as_f32x8()))
12896 }
12897}
12898
12899#[inline]
12903#[target_feature(enable = "avx512f,avx512vl")]
12904#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12905#[cfg_attr(test, assert_instr(vcvtdq2ps))]
12906#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12907pub const fn _mm256_maskz_cvtepi32_ps(k: __mmask8, a: __m256i) -> __m256 {
12908 unsafe {
12909 let convert = _mm256_cvtepi32_ps(a).as_f32x8();
12910 transmute(simd_select_bitmask(k, convert, f32x8::ZERO))
12911 }
12912}
12913
12914#[inline]
12918#[target_feature(enable = "avx512f,avx512vl")]
12919#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12920#[cfg_attr(test, assert_instr(vcvtdq2ps))]
12921#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12922pub const fn _mm_mask_cvtepi32_ps(src: __m128, k: __mmask8, a: __m128i) -> __m128 {
12923 unsafe {
12924 let convert = _mm_cvtepi32_ps(a).as_f32x4();
12925 transmute(simd_select_bitmask(k, convert, src.as_f32x4()))
12926 }
12927}
12928
12929#[inline]
12933#[target_feature(enable = "avx512f,avx512vl")]
12934#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12935#[cfg_attr(test, assert_instr(vcvtdq2ps))]
12936#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12937pub const fn _mm_maskz_cvtepi32_ps(k: __mmask8, a: __m128i) -> __m128 {
12938 unsafe {
12939 let convert = _mm_cvtepi32_ps(a).as_f32x4();
12940 transmute(simd_select_bitmask(k, convert, f32x4::ZERO))
12941 }
12942}
12943
12944#[inline]
12948#[target_feature(enable = "avx512f")]
12949#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12950#[cfg_attr(test, assert_instr(vcvtdq2pd))]
12951#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12952pub const fn _mm512_cvtepi32_pd(a: __m256i) -> __m512d {
12953 unsafe {
12954 let a = a.as_i32x8();
12955 transmute::<f64x8, _>(simd_cast(a))
12956 }
12957}
12958
12959#[inline]
12963#[target_feature(enable = "avx512f")]
12964#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12965#[cfg_attr(test, assert_instr(vcvtdq2pd))]
12966#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12967pub const fn _mm512_mask_cvtepi32_pd(src: __m512d, k: __mmask8, a: __m256i) -> __m512d {
12968 unsafe {
12969 let convert = _mm512_cvtepi32_pd(a).as_f64x8();
12970 transmute(simd_select_bitmask(k, convert, src.as_f64x8()))
12971 }
12972}
12973
12974#[inline]
12978#[target_feature(enable = "avx512f")]
12979#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12980#[cfg_attr(test, assert_instr(vcvtdq2pd))]
12981#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12982pub const fn _mm512_maskz_cvtepi32_pd(k: __mmask8, a: __m256i) -> __m512d {
12983 unsafe {
12984 let convert = _mm512_cvtepi32_pd(a).as_f64x8();
12985 transmute(simd_select_bitmask(k, convert, f64x8::ZERO))
12986 }
12987}
12988
12989#[inline]
12993#[target_feature(enable = "avx512f,avx512vl")]
12994#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
12995#[cfg_attr(test, assert_instr(vcvtdq2pd))]
12996#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
12997pub const fn _mm256_mask_cvtepi32_pd(src: __m256d, k: __mmask8, a: __m128i) -> __m256d {
12998 unsafe {
12999 let convert = _mm256_cvtepi32_pd(a).as_f64x4();
13000 transmute(simd_select_bitmask(k, convert, src.as_f64x4()))
13001 }
13002}
13003
13004#[inline]
13008#[target_feature(enable = "avx512f,avx512vl")]
13009#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13010#[cfg_attr(test, assert_instr(vcvtdq2pd))]
13011#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13012pub const fn _mm256_maskz_cvtepi32_pd(k: __mmask8, a: __m128i) -> __m256d {
13013 unsafe {
13014 let convert = _mm256_cvtepi32_pd(a).as_f64x4();
13015 transmute(simd_select_bitmask(k, convert, f64x4::ZERO))
13016 }
13017}
13018
13019#[inline]
13023#[target_feature(enable = "avx512f,avx512vl")]
13024#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13025#[cfg_attr(test, assert_instr(vcvtdq2pd))]
13026#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13027pub const fn _mm_mask_cvtepi32_pd(src: __m128d, k: __mmask8, a: __m128i) -> __m128d {
13028 unsafe {
13029 let convert = _mm_cvtepi32_pd(a).as_f64x2();
13030 transmute(simd_select_bitmask(k, convert, src.as_f64x2()))
13031 }
13032}
13033
13034#[inline]
13038#[target_feature(enable = "avx512f,avx512vl")]
13039#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13040#[cfg_attr(test, assert_instr(vcvtdq2pd))]
13041#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13042pub const fn _mm_maskz_cvtepi32_pd(k: __mmask8, a: __m128i) -> __m128d {
13043 unsafe {
13044 let convert = _mm_cvtepi32_pd(a).as_f64x2();
13045 transmute(simd_select_bitmask(k, convert, f64x2::ZERO))
13046 }
13047}
13048
13049#[inline]
13053#[target_feature(enable = "avx512f")]
13054#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13055#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13056#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13057pub const fn _mm512_cvtepu32_ps(a: __m512i) -> __m512 {
13058 unsafe {
13059 let a = a.as_u32x16();
13060 transmute::<f32x16, _>(simd_cast(a))
13061 }
13062}
13063
13064#[inline]
13068#[target_feature(enable = "avx512f")]
13069#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13070#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13071#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13072pub const fn _mm512_mask_cvtepu32_ps(src: __m512, k: __mmask16, a: __m512i) -> __m512 {
13073 unsafe {
13074 let convert = _mm512_cvtepu32_ps(a).as_f32x16();
13075 transmute(simd_select_bitmask(k, convert, src.as_f32x16()))
13076 }
13077}
13078
13079#[inline]
13083#[target_feature(enable = "avx512f")]
13084#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13085#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13086#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13087pub const fn _mm512_maskz_cvtepu32_ps(k: __mmask16, a: __m512i) -> __m512 {
13088 unsafe {
13089 let convert = _mm512_cvtepu32_ps(a).as_f32x16();
13090 transmute(simd_select_bitmask(k, convert, f32x16::ZERO))
13091 }
13092}
13093
13094#[inline]
13099#[target_feature(enable = "avx512f,avx512vl")]
13100#[unstable(
13101 feature = "stdarch_x86_avx512_vl_u32_to_f32_conversions",
13102 issue = "161585"
13103)]
13104#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13105#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13106pub const fn _mm256_cvtepu32_ps(a: __m256i) -> __m256 {
13107 unsafe {
13108 let a = a.as_u32x8();
13109 transmute::<f32x8, _>(simd_cast(a))
13110 }
13111}
13112
13113#[inline]
13118#[target_feature(enable = "avx512f,avx512vl")]
13119#[unstable(
13120 feature = "stdarch_x86_avx512_vl_u32_to_f32_conversions",
13121 issue = "161585"
13122)]
13123#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13124#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13125pub const fn _mm256_mask_cvtepu32_ps(src: __m256, k: __mmask8, a: __m256i) -> __m256 {
13126 unsafe {
13127 let convert = _mm256_cvtepu32_ps(a).as_f32x8();
13128 transmute(simd_select_bitmask(k, convert, src.as_f32x8()))
13129 }
13130}
13131
13132#[inline]
13137#[target_feature(enable = "avx512f,avx512vl")]
13138#[unstable(
13139 feature = "stdarch_x86_avx512_vl_u32_to_f32_conversions",
13140 issue = "161585"
13141)]
13142#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13143#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13144pub const fn _mm256_maskz_cvtepu32_ps(k: __mmask8, a: __m256i) -> __m256 {
13145 unsafe {
13146 let convert = _mm256_cvtepu32_ps(a).as_f32x8();
13147 transmute(simd_select_bitmask(k, convert, f32x8::ZERO))
13148 }
13149}
13150
13151#[inline]
13156#[target_feature(enable = "avx512f,avx512vl")]
13157#[unstable(
13158 feature = "stdarch_x86_avx512_vl_u32_to_f32_conversions",
13159 issue = "161585"
13160)]
13161#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13162#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13163pub const fn _mm_cvtepu32_ps(a: __m128i) -> __m128 {
13164 unsafe {
13165 let a = a.as_u32x4();
13166 transmute::<f32x4, _>(simd_cast(a))
13167 }
13168}
13169
13170#[inline]
13176#[target_feature(enable = "avx512f,avx512vl")]
13177#[unstable(
13178 feature = "stdarch_x86_avx512_vl_u32_to_f32_conversions",
13179 issue = "161585"
13180)]
13181#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13182#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13183pub const fn _mm_mask_cvtepu32_ps(src: __m128, k: __mmask8, a: __m128i) -> __m128 {
13184 unsafe {
13185 let convert = _mm_cvtepu32_ps(a).as_f32x4();
13186 transmute(simd_select_bitmask(k, convert, src.as_f32x4()))
13187 }
13188}
13189
13190#[inline]
13196#[target_feature(enable = "avx512f,avx512vl")]
13197#[unstable(
13198 feature = "stdarch_x86_avx512_vl_u32_to_f32_conversions",
13199 issue = "161585"
13200)]
13201#[cfg_attr(test, assert_instr(vcvtudq2ps))]
13202#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13203pub const fn _mm_maskz_cvtepu32_ps(k: __mmask8, a: __m128i) -> __m128 {
13204 unsafe {
13205 let convert = _mm_cvtepu32_ps(a).as_f32x4();
13206 transmute(simd_select_bitmask(k, convert, f32x4::ZERO))
13207 }
13208}
13209
13210#[inline]
13214#[target_feature(enable = "avx512f")]
13215#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13216#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13217#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13218pub const fn _mm512_cvtepu32_pd(a: __m256i) -> __m512d {
13219 unsafe {
13220 let a = a.as_u32x8();
13221 transmute::<f64x8, _>(simd_cast(a))
13222 }
13223}
13224
13225#[inline]
13229#[target_feature(enable = "avx512f")]
13230#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13231#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13232#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13233pub const fn _mm512_mask_cvtepu32_pd(src: __m512d, k: __mmask8, a: __m256i) -> __m512d {
13234 unsafe {
13235 let convert = _mm512_cvtepu32_pd(a).as_f64x8();
13236 transmute(simd_select_bitmask(k, convert, src.as_f64x8()))
13237 }
13238}
13239
13240#[inline]
13244#[target_feature(enable = "avx512f")]
13245#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13246#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13247#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13248pub const fn _mm512_maskz_cvtepu32_pd(k: __mmask8, a: __m256i) -> __m512d {
13249 unsafe {
13250 let convert = _mm512_cvtepu32_pd(a).as_f64x8();
13251 transmute(simd_select_bitmask(k, convert, f64x8::ZERO))
13252 }
13253}
13254
13255#[inline]
13259#[target_feature(enable = "avx512f,avx512vl")]
13260#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13261#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13262#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13263pub const fn _mm256_cvtepu32_pd(a: __m128i) -> __m256d {
13264 unsafe {
13265 let a = a.as_u32x4();
13266 transmute::<f64x4, _>(simd_cast(a))
13267 }
13268}
13269
13270#[inline]
13274#[target_feature(enable = "avx512f,avx512vl")]
13275#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13276#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13277#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13278pub const fn _mm256_mask_cvtepu32_pd(src: __m256d, k: __mmask8, a: __m128i) -> __m256d {
13279 unsafe {
13280 let convert = _mm256_cvtepu32_pd(a).as_f64x4();
13281 transmute(simd_select_bitmask(k, convert, src.as_f64x4()))
13282 }
13283}
13284
13285#[inline]
13289#[target_feature(enable = "avx512f,avx512vl")]
13290#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13291#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13292#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13293pub const fn _mm256_maskz_cvtepu32_pd(k: __mmask8, a: __m128i) -> __m256d {
13294 unsafe {
13295 let convert = _mm256_cvtepu32_pd(a).as_f64x4();
13296 transmute(simd_select_bitmask(k, convert, f64x4::ZERO))
13297 }
13298}
13299
13300#[inline]
13304#[target_feature(enable = "avx512f,avx512vl")]
13305#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13306#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13307#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13308pub const fn _mm_cvtepu32_pd(a: __m128i) -> __m128d {
13309 unsafe {
13310 let a = a.as_u32x4();
13311 let u64: u32x2 = simd_shuffle!(a, a, [0, 1]);
13312 transmute::<f64x2, _>(simd_cast(u64))
13313 }
13314}
13315
13316#[inline]
13320#[target_feature(enable = "avx512f,avx512vl")]
13321#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13322#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13323#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13324pub const fn _mm_mask_cvtepu32_pd(src: __m128d, k: __mmask8, a: __m128i) -> __m128d {
13325 unsafe {
13326 let convert = _mm_cvtepu32_pd(a).as_f64x2();
13327 transmute(simd_select_bitmask(k, convert, src.as_f64x2()))
13328 }
13329}
13330
13331#[inline]
13335#[target_feature(enable = "avx512f,avx512vl")]
13336#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13337#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13338#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13339pub const fn _mm_maskz_cvtepu32_pd(k: __mmask8, a: __m128i) -> __m128d {
13340 unsafe {
13341 let convert = _mm_cvtepu32_pd(a).as_f64x2();
13342 transmute(simd_select_bitmask(k, convert, f64x2::ZERO))
13343 }
13344}
13345
13346#[inline]
13350#[target_feature(enable = "avx512f")]
13351#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13352#[cfg_attr(test, assert_instr(vcvtdq2pd))]
13353#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13354pub const fn _mm512_cvtepi32lo_pd(v2: __m512i) -> __m512d {
13355 unsafe {
13356 let v2 = v2.as_i32x16();
13357 let v256: i32x8 = simd_shuffle!(v2, v2, [0, 1, 2, 3, 4, 5, 6, 7]);
13358 transmute::<f64x8, _>(simd_cast(v256))
13359 }
13360}
13361
13362#[inline]
13366#[target_feature(enable = "avx512f")]
13367#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13368#[cfg_attr(test, assert_instr(vcvtdq2pd))]
13369#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13370pub const fn _mm512_mask_cvtepi32lo_pd(src: __m512d, k: __mmask8, v2: __m512i) -> __m512d {
13371 unsafe {
13372 let convert = _mm512_cvtepi32lo_pd(v2).as_f64x8();
13373 transmute(simd_select_bitmask(k, convert, src.as_f64x8()))
13374 }
13375}
13376
13377#[inline]
13381#[target_feature(enable = "avx512f")]
13382#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13383#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13384#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13385pub const fn _mm512_cvtepu32lo_pd(v2: __m512i) -> __m512d {
13386 unsafe {
13387 let v2 = v2.as_u32x16();
13388 let v256: u32x8 = simd_shuffle!(v2, v2, [0, 1, 2, 3, 4, 5, 6, 7]);
13389 transmute::<f64x8, _>(simd_cast(v256))
13390 }
13391}
13392
13393#[inline]
13397#[target_feature(enable = "avx512f")]
13398#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13399#[cfg_attr(test, assert_instr(vcvtudq2pd))]
13400#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13401pub const fn _mm512_mask_cvtepu32lo_pd(src: __m512d, k: __mmask8, v2: __m512i) -> __m512d {
13402 unsafe {
13403 let convert = _mm512_cvtepu32lo_pd(v2).as_f64x8();
13404 transmute(simd_select_bitmask(k, convert, src.as_f64x8()))
13405 }
13406}
13407
13408#[inline]
13412#[target_feature(enable = "avx512f")]
13413#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13414#[cfg_attr(test, assert_instr(vpmovdw))]
13415#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13416pub const fn _mm512_cvtepi32_epi16(a: __m512i) -> __m256i {
13417 unsafe {
13418 let a = a.as_i32x16();
13419 transmute::<i16x16, _>(simd_cast(a))
13420 }
13421}
13422
13423#[inline]
13427#[target_feature(enable = "avx512f")]
13428#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13429#[cfg_attr(test, assert_instr(vpmovdw))]
13430#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13431pub const fn _mm512_mask_cvtepi32_epi16(src: __m256i, k: __mmask16, a: __m512i) -> __m256i {
13432 unsafe {
13433 let convert = _mm512_cvtepi32_epi16(a).as_i16x16();
13434 transmute(simd_select_bitmask(k, convert, src.as_i16x16()))
13435 }
13436}
13437
13438#[inline]
13442#[target_feature(enable = "avx512f")]
13443#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13444#[cfg_attr(test, assert_instr(vpmovdw))]
13445#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13446pub const fn _mm512_maskz_cvtepi32_epi16(k: __mmask16, a: __m512i) -> __m256i {
13447 unsafe {
13448 let convert = _mm512_cvtepi32_epi16(a).as_i16x16();
13449 transmute(simd_select_bitmask(k, convert, i16x16::ZERO))
13450 }
13451}
13452
13453#[inline]
13457#[target_feature(enable = "avx512f,avx512vl")]
13458#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13459#[cfg_attr(test, assert_instr(vpmovdw))]
13460#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13461pub const fn _mm256_cvtepi32_epi16(a: __m256i) -> __m128i {
13462 unsafe {
13463 let a = a.as_i32x8();
13464 transmute::<i16x8, _>(simd_cast(a))
13465 }
13466}
13467
13468#[inline]
13472#[target_feature(enable = "avx512f,avx512vl")]
13473#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13474#[cfg_attr(test, assert_instr(vpmovdw))]
13475#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13476pub const fn _mm256_mask_cvtepi32_epi16(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
13477 unsafe {
13478 let convert = _mm256_cvtepi32_epi16(a).as_i16x8();
13479 transmute(simd_select_bitmask(k, convert, src.as_i16x8()))
13480 }
13481}
13482
13483#[inline]
13487#[target_feature(enable = "avx512f,avx512vl")]
13488#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13489#[cfg_attr(test, assert_instr(vpmovdw))]
13490#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13491pub const fn _mm256_maskz_cvtepi32_epi16(k: __mmask8, a: __m256i) -> __m128i {
13492 unsafe {
13493 let convert = _mm256_cvtepi32_epi16(a).as_i16x8();
13494 transmute(simd_select_bitmask(k, convert, i16x8::ZERO))
13495 }
13496}
13497
13498#[inline]
13502#[target_feature(enable = "avx512f,avx512vl")]
13503#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13504#[cfg_attr(test, assert_instr(vpmovdw))]
13505pub fn _mm_cvtepi32_epi16(a: __m128i) -> __m128i {
13506 unsafe { transmute(vpmovdw128(a.as_i32x4(), i16x8::ZERO, 0b11111111)) }
13507}
13508
13509#[inline]
13513#[target_feature(enable = "avx512f,avx512vl")]
13514#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13515#[cfg_attr(test, assert_instr(vpmovdw))]
13516pub fn _mm_mask_cvtepi32_epi16(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
13517 unsafe { transmute(vpmovdw128(a.as_i32x4(), src.as_i16x8(), k)) }
13518}
13519
13520#[inline]
13524#[target_feature(enable = "avx512f,avx512vl")]
13525#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13526#[cfg_attr(test, assert_instr(vpmovdw))]
13527pub fn _mm_maskz_cvtepi32_epi16(k: __mmask8, a: __m128i) -> __m128i {
13528 unsafe { transmute(vpmovdw128(a.as_i32x4(), i16x8::ZERO, k)) }
13529}
13530
13531#[inline]
13535#[target_feature(enable = "avx512f")]
13536#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13537#[cfg_attr(test, assert_instr(vpmovdb))]
13538#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13539pub const fn _mm512_cvtepi32_epi8(a: __m512i) -> __m128i {
13540 unsafe {
13541 let a = a.as_i32x16();
13542 transmute::<i8x16, _>(simd_cast(a))
13543 }
13544}
13545
13546#[inline]
13550#[target_feature(enable = "avx512f")]
13551#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13552#[cfg_attr(test, assert_instr(vpmovdb))]
13553#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13554pub const fn _mm512_mask_cvtepi32_epi8(src: __m128i, k: __mmask16, a: __m512i) -> __m128i {
13555 unsafe {
13556 let convert = _mm512_cvtepi32_epi8(a).as_i8x16();
13557 transmute(simd_select_bitmask(k, convert, src.as_i8x16()))
13558 }
13559}
13560
13561#[inline]
13565#[target_feature(enable = "avx512f")]
13566#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13567#[cfg_attr(test, assert_instr(vpmovdb))]
13568#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13569pub const fn _mm512_maskz_cvtepi32_epi8(k: __mmask16, a: __m512i) -> __m128i {
13570 unsafe {
13571 let convert = _mm512_cvtepi32_epi8(a).as_i8x16();
13572 transmute(simd_select_bitmask(k, convert, i8x16::ZERO))
13573 }
13574}
13575
13576#[inline]
13580#[target_feature(enable = "avx512f,avx512vl")]
13581#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13582#[cfg_attr(test, assert_instr(vpmovdb))]
13583pub fn _mm256_cvtepi32_epi8(a: __m256i) -> __m128i {
13584 unsafe { transmute(vpmovdb256(a.as_i32x8(), i8x16::ZERO, 0b11111111)) }
13585}
13586
13587#[inline]
13591#[target_feature(enable = "avx512f,avx512vl")]
13592#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13593#[cfg_attr(test, assert_instr(vpmovdb))]
13594pub fn _mm256_mask_cvtepi32_epi8(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
13595 unsafe { transmute(vpmovdb256(a.as_i32x8(), src.as_i8x16(), k)) }
13596}
13597
13598#[inline]
13602#[target_feature(enable = "avx512f,avx512vl")]
13603#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13604#[cfg_attr(test, assert_instr(vpmovdb))]
13605pub fn _mm256_maskz_cvtepi32_epi8(k: __mmask8, a: __m256i) -> __m128i {
13606 unsafe { transmute(vpmovdb256(a.as_i32x8(), i8x16::ZERO, k)) }
13607}
13608
13609#[inline]
13613#[target_feature(enable = "avx512f,avx512vl")]
13614#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13615#[cfg_attr(test, assert_instr(vpmovdb))]
13616pub fn _mm_cvtepi32_epi8(a: __m128i) -> __m128i {
13617 unsafe { transmute(vpmovdb128(a.as_i32x4(), i8x16::ZERO, 0b11111111)) }
13618}
13619
13620#[inline]
13624#[target_feature(enable = "avx512f,avx512vl")]
13625#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13626#[cfg_attr(test, assert_instr(vpmovdb))]
13627pub fn _mm_mask_cvtepi32_epi8(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
13628 unsafe { transmute(vpmovdb128(a.as_i32x4(), src.as_i8x16(), k)) }
13629}
13630
13631#[inline]
13635#[target_feature(enable = "avx512f,avx512vl")]
13636#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13637#[cfg_attr(test, assert_instr(vpmovdb))]
13638pub fn _mm_maskz_cvtepi32_epi8(k: __mmask8, a: __m128i) -> __m128i {
13639 unsafe { transmute(vpmovdb128(a.as_i32x4(), i8x16::ZERO, k)) }
13640}
13641
13642#[inline]
13646#[target_feature(enable = "avx512f")]
13647#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13648#[cfg_attr(test, assert_instr(vpmovqd))]
13649#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13650pub const fn _mm512_cvtepi64_epi32(a: __m512i) -> __m256i {
13651 unsafe {
13652 let a = a.as_i64x8();
13653 transmute::<i32x8, _>(simd_cast(a))
13654 }
13655}
13656
13657#[inline]
13661#[target_feature(enable = "avx512f")]
13662#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13663#[cfg_attr(test, assert_instr(vpmovqd))]
13664#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13665pub const fn _mm512_mask_cvtepi64_epi32(src: __m256i, k: __mmask8, a: __m512i) -> __m256i {
13666 unsafe {
13667 let convert = _mm512_cvtepi64_epi32(a).as_i32x8();
13668 transmute(simd_select_bitmask(k, convert, src.as_i32x8()))
13669 }
13670}
13671
13672#[inline]
13676#[target_feature(enable = "avx512f")]
13677#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13678#[cfg_attr(test, assert_instr(vpmovqd))]
13679#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13680pub const fn _mm512_maskz_cvtepi64_epi32(k: __mmask8, a: __m512i) -> __m256i {
13681 unsafe {
13682 let convert = _mm512_cvtepi64_epi32(a).as_i32x8();
13683 transmute(simd_select_bitmask(k, convert, i32x8::ZERO))
13684 }
13685}
13686
13687#[inline]
13691#[target_feature(enable = "avx512f,avx512vl")]
13692#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13693#[cfg_attr(test, assert_instr(vpmovqd))]
13694#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13695pub const fn _mm256_cvtepi64_epi32(a: __m256i) -> __m128i {
13696 unsafe {
13697 let a = a.as_i64x4();
13698 transmute::<i32x4, _>(simd_cast(a))
13699 }
13700}
13701
13702#[inline]
13706#[target_feature(enable = "avx512f,avx512vl")]
13707#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13708#[cfg_attr(test, assert_instr(vpmovqd))]
13709#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13710pub const fn _mm256_mask_cvtepi64_epi32(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
13711 unsafe {
13712 let convert = _mm256_cvtepi64_epi32(a).as_i32x4();
13713 transmute(simd_select_bitmask(k, convert, src.as_i32x4()))
13714 }
13715}
13716
13717#[inline]
13721#[target_feature(enable = "avx512f,avx512vl")]
13722#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13723#[cfg_attr(test, assert_instr(vpmovqd))]
13724#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13725pub const fn _mm256_maskz_cvtepi64_epi32(k: __mmask8, a: __m256i) -> __m128i {
13726 unsafe {
13727 let convert = _mm256_cvtepi64_epi32(a).as_i32x4();
13728 transmute(simd_select_bitmask(k, convert, i32x4::ZERO))
13729 }
13730}
13731
13732#[inline]
13736#[target_feature(enable = "avx512f,avx512vl")]
13737#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13738#[cfg_attr(test, assert_instr(vpmovqd))]
13739pub fn _mm_cvtepi64_epi32(a: __m128i) -> __m128i {
13740 unsafe { transmute(vpmovqd128(a.as_i64x2(), i32x4::ZERO, 0b11111111)) }
13741}
13742
13743#[inline]
13747#[target_feature(enable = "avx512f,avx512vl")]
13748#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13749#[cfg_attr(test, assert_instr(vpmovqd))]
13750pub fn _mm_mask_cvtepi64_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
13751 unsafe { transmute(vpmovqd128(a.as_i64x2(), src.as_i32x4(), k)) }
13752}
13753
13754#[inline]
13758#[target_feature(enable = "avx512f,avx512vl")]
13759#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13760#[cfg_attr(test, assert_instr(vpmovqd))]
13761pub fn _mm_maskz_cvtepi64_epi32(k: __mmask8, a: __m128i) -> __m128i {
13762 unsafe { transmute(vpmovqd128(a.as_i64x2(), i32x4::ZERO, k)) }
13763}
13764
13765#[inline]
13769#[target_feature(enable = "avx512f")]
13770#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13771#[cfg_attr(test, assert_instr(vpmovqw))]
13772#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13773pub const fn _mm512_cvtepi64_epi16(a: __m512i) -> __m128i {
13774 unsafe {
13775 let a = a.as_i64x8();
13776 transmute::<i16x8, _>(simd_cast(a))
13777 }
13778}
13779
13780#[inline]
13784#[target_feature(enable = "avx512f")]
13785#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13786#[cfg_attr(test, assert_instr(vpmovqw))]
13787#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13788pub const fn _mm512_mask_cvtepi64_epi16(src: __m128i, k: __mmask8, a: __m512i) -> __m128i {
13789 unsafe {
13790 let convert = _mm512_cvtepi64_epi16(a).as_i16x8();
13791 transmute(simd_select_bitmask(k, convert, src.as_i16x8()))
13792 }
13793}
13794
13795#[inline]
13799#[target_feature(enable = "avx512f")]
13800#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13801#[cfg_attr(test, assert_instr(vpmovqw))]
13802#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
13803pub const fn _mm512_maskz_cvtepi64_epi16(k: __mmask8, a: __m512i) -> __m128i {
13804 unsafe {
13805 let convert = _mm512_cvtepi64_epi16(a).as_i16x8();
13806 transmute(simd_select_bitmask(k, convert, i16x8::ZERO))
13807 }
13808}
13809
13810#[inline]
13814#[target_feature(enable = "avx512f,avx512vl")]
13815#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13816#[cfg_attr(test, assert_instr(vpmovqw))]
13817pub fn _mm256_cvtepi64_epi16(a: __m256i) -> __m128i {
13818 unsafe { transmute(vpmovqw256(a.as_i64x4(), i16x8::ZERO, 0b11111111)) }
13819}
13820
13821#[inline]
13825#[target_feature(enable = "avx512f,avx512vl")]
13826#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13827#[cfg_attr(test, assert_instr(vpmovqw))]
13828pub fn _mm256_mask_cvtepi64_epi16(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
13829 unsafe { transmute(vpmovqw256(a.as_i64x4(), src.as_i16x8(), k)) }
13830}
13831
13832#[inline]
13836#[target_feature(enable = "avx512f,avx512vl")]
13837#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13838#[cfg_attr(test, assert_instr(vpmovqw))]
13839pub fn _mm256_maskz_cvtepi64_epi16(k: __mmask8, a: __m256i) -> __m128i {
13840 unsafe { transmute(vpmovqw256(a.as_i64x4(), i16x8::ZERO, k)) }
13841}
13842
13843#[inline]
13847#[target_feature(enable = "avx512f,avx512vl")]
13848#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13849#[cfg_attr(test, assert_instr(vpmovqw))]
13850pub fn _mm_cvtepi64_epi16(a: __m128i) -> __m128i {
13851 unsafe { transmute(vpmovqw128(a.as_i64x2(), i16x8::ZERO, 0b11111111)) }
13852}
13853
13854#[inline]
13858#[target_feature(enable = "avx512f,avx512vl")]
13859#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13860#[cfg_attr(test, assert_instr(vpmovqw))]
13861pub fn _mm_mask_cvtepi64_epi16(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
13862 unsafe { transmute(vpmovqw128(a.as_i64x2(), src.as_i16x8(), k)) }
13863}
13864
13865#[inline]
13869#[target_feature(enable = "avx512f,avx512vl")]
13870#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13871#[cfg_attr(test, assert_instr(vpmovqw))]
13872pub fn _mm_maskz_cvtepi64_epi16(k: __mmask8, a: __m128i) -> __m128i {
13873 unsafe { transmute(vpmovqw128(a.as_i64x2(), i16x8::ZERO, k)) }
13874}
13875
13876#[inline]
13880#[target_feature(enable = "avx512f")]
13881#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13882#[cfg_attr(test, assert_instr(vpmovqb))]
13883pub fn _mm512_cvtepi64_epi8(a: __m512i) -> __m128i {
13884 unsafe { transmute(vpmovqb(a.as_i64x8(), i8x16::ZERO, 0b11111111)) }
13885}
13886
13887#[inline]
13891#[target_feature(enable = "avx512f")]
13892#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13893#[cfg_attr(test, assert_instr(vpmovqb))]
13894pub fn _mm512_mask_cvtepi64_epi8(src: __m128i, k: __mmask8, a: __m512i) -> __m128i {
13895 unsafe { transmute(vpmovqb(a.as_i64x8(), src.as_i8x16(), k)) }
13896}
13897
13898#[inline]
13902#[target_feature(enable = "avx512f")]
13903#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13904#[cfg_attr(test, assert_instr(vpmovqb))]
13905pub fn _mm512_maskz_cvtepi64_epi8(k: __mmask8, a: __m512i) -> __m128i {
13906 unsafe { transmute(vpmovqb(a.as_i64x8(), i8x16::ZERO, k)) }
13907}
13908
13909#[inline]
13913#[target_feature(enable = "avx512f,avx512vl")]
13914#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13915#[cfg_attr(test, assert_instr(vpmovqb))]
13916pub fn _mm256_cvtepi64_epi8(a: __m256i) -> __m128i {
13917 unsafe { transmute(vpmovqb256(a.as_i64x4(), i8x16::ZERO, 0b11111111)) }
13918}
13919
13920#[inline]
13924#[target_feature(enable = "avx512f,avx512vl")]
13925#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13926#[cfg_attr(test, assert_instr(vpmovqb))]
13927pub fn _mm256_mask_cvtepi64_epi8(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
13928 unsafe { transmute(vpmovqb256(a.as_i64x4(), src.as_i8x16(), k)) }
13929}
13930
13931#[inline]
13935#[target_feature(enable = "avx512f,avx512vl")]
13936#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13937#[cfg_attr(test, assert_instr(vpmovqb))]
13938pub fn _mm256_maskz_cvtepi64_epi8(k: __mmask8, a: __m256i) -> __m128i {
13939 unsafe { transmute(vpmovqb256(a.as_i64x4(), i8x16::ZERO, k)) }
13940}
13941
13942#[inline]
13946#[target_feature(enable = "avx512f,avx512vl")]
13947#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13948#[cfg_attr(test, assert_instr(vpmovqb))]
13949pub fn _mm_cvtepi64_epi8(a: __m128i) -> __m128i {
13950 unsafe { transmute(vpmovqb128(a.as_i64x2(), i8x16::ZERO, 0b11111111)) }
13951}
13952
13953#[inline]
13957#[target_feature(enable = "avx512f,avx512vl")]
13958#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13959#[cfg_attr(test, assert_instr(vpmovqb))]
13960pub fn _mm_mask_cvtepi64_epi8(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
13961 unsafe { transmute(vpmovqb128(a.as_i64x2(), src.as_i8x16(), k)) }
13962}
13963
13964#[inline]
13968#[target_feature(enable = "avx512f,avx512vl")]
13969#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13970#[cfg_attr(test, assert_instr(vpmovqb))]
13971pub fn _mm_maskz_cvtepi64_epi8(k: __mmask8, a: __m128i) -> __m128i {
13972 unsafe { transmute(vpmovqb128(a.as_i64x2(), i8x16::ZERO, k)) }
13973}
13974
13975#[inline]
13979#[target_feature(enable = "avx512f")]
13980#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13981#[cfg_attr(test, assert_instr(vpmovsdw))]
13982pub fn _mm512_cvtsepi32_epi16(a: __m512i) -> __m256i {
13983 unsafe { transmute(vpmovsdw(a.as_i32x16(), i16x16::ZERO, 0b11111111_11111111)) }
13984}
13985
13986#[inline]
13990#[target_feature(enable = "avx512f")]
13991#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
13992#[cfg_attr(test, assert_instr(vpmovsdw))]
13993pub fn _mm512_mask_cvtsepi32_epi16(src: __m256i, k: __mmask16, a: __m512i) -> __m256i {
13994 unsafe { transmute(vpmovsdw(a.as_i32x16(), src.as_i16x16(), k)) }
13995}
13996
13997#[inline]
14001#[target_feature(enable = "avx512f")]
14002#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14003#[cfg_attr(test, assert_instr(vpmovsdw))]
14004pub fn _mm512_maskz_cvtsepi32_epi16(k: __mmask16, a: __m512i) -> __m256i {
14005 unsafe { transmute(vpmovsdw(a.as_i32x16(), i16x16::ZERO, k)) }
14006}
14007
14008#[inline]
14012#[target_feature(enable = "avx512f,avx512vl")]
14013#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14014#[cfg_attr(test, assert_instr(vpmovsdw))]
14015pub fn _mm256_cvtsepi32_epi16(a: __m256i) -> __m128i {
14016 unsafe { transmute(vpmovsdw256(a.as_i32x8(), i16x8::ZERO, 0b11111111)) }
14017}
14018
14019#[inline]
14023#[target_feature(enable = "avx512f,avx512vl")]
14024#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14025#[cfg_attr(test, assert_instr(vpmovsdw))]
14026pub fn _mm256_mask_cvtsepi32_epi16(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14027 unsafe { transmute(vpmovsdw256(a.as_i32x8(), src.as_i16x8(), k)) }
14028}
14029
14030#[inline]
14034#[target_feature(enable = "avx512f,avx512vl")]
14035#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14036#[cfg_attr(test, assert_instr(vpmovsdw))]
14037pub fn _mm256_maskz_cvtsepi32_epi16(k: __mmask8, a: __m256i) -> __m128i {
14038 unsafe { transmute(vpmovsdw256(a.as_i32x8(), i16x8::ZERO, k)) }
14039}
14040
14041#[inline]
14045#[target_feature(enable = "avx512f,avx512vl")]
14046#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14047#[cfg_attr(test, assert_instr(vpmovsdw))]
14048pub fn _mm_cvtsepi32_epi16(a: __m128i) -> __m128i {
14049 unsafe { transmute(vpmovsdw128(a.as_i32x4(), i16x8::ZERO, 0b11111111)) }
14050}
14051
14052#[inline]
14056#[target_feature(enable = "avx512f,avx512vl")]
14057#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14058#[cfg_attr(test, assert_instr(vpmovsdw))]
14059pub fn _mm_mask_cvtsepi32_epi16(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14060 unsafe { transmute(vpmovsdw128(a.as_i32x4(), src.as_i16x8(), k)) }
14061}
14062
14063#[inline]
14067#[target_feature(enable = "avx512f,avx512vl")]
14068#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14069#[cfg_attr(test, assert_instr(vpmovsdw))]
14070pub fn _mm_maskz_cvtsepi32_epi16(k: __mmask8, a: __m128i) -> __m128i {
14071 unsafe { transmute(vpmovsdw128(a.as_i32x4(), i16x8::ZERO, k)) }
14072}
14073
14074#[inline]
14078#[target_feature(enable = "avx512f")]
14079#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14080#[cfg_attr(test, assert_instr(vpmovsdb))]
14081pub fn _mm512_cvtsepi32_epi8(a: __m512i) -> __m128i {
14082 unsafe { transmute(vpmovsdb(a.as_i32x16(), i8x16::ZERO, 0b11111111_11111111)) }
14083}
14084
14085#[inline]
14089#[target_feature(enable = "avx512f")]
14090#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14091#[cfg_attr(test, assert_instr(vpmovsdb))]
14092pub fn _mm512_mask_cvtsepi32_epi8(src: __m128i, k: __mmask16, a: __m512i) -> __m128i {
14093 unsafe { transmute(vpmovsdb(a.as_i32x16(), src.as_i8x16(), k)) }
14094}
14095
14096#[inline]
14100#[target_feature(enable = "avx512f")]
14101#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14102#[cfg_attr(test, assert_instr(vpmovsdb))]
14103pub fn _mm512_maskz_cvtsepi32_epi8(k: __mmask16, a: __m512i) -> __m128i {
14104 unsafe { transmute(vpmovsdb(a.as_i32x16(), i8x16::ZERO, k)) }
14105}
14106
14107#[inline]
14111#[target_feature(enable = "avx512f,avx512vl")]
14112#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14113#[cfg_attr(test, assert_instr(vpmovsdb))]
14114pub fn _mm256_cvtsepi32_epi8(a: __m256i) -> __m128i {
14115 unsafe { transmute(vpmovsdb256(a.as_i32x8(), i8x16::ZERO, 0b11111111)) }
14116}
14117
14118#[inline]
14122#[target_feature(enable = "avx512f,avx512vl")]
14123#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14124#[cfg_attr(test, assert_instr(vpmovsdb))]
14125pub fn _mm256_mask_cvtsepi32_epi8(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14126 unsafe { transmute(vpmovsdb256(a.as_i32x8(), src.as_i8x16(), k)) }
14127}
14128
14129#[inline]
14133#[target_feature(enable = "avx512f,avx512vl")]
14134#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14135#[cfg_attr(test, assert_instr(vpmovsdb))]
14136pub fn _mm256_maskz_cvtsepi32_epi8(k: __mmask8, a: __m256i) -> __m128i {
14137 unsafe { transmute(vpmovsdb256(a.as_i32x8(), i8x16::ZERO, k)) }
14138}
14139
14140#[inline]
14144#[target_feature(enable = "avx512f,avx512vl")]
14145#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14146#[cfg_attr(test, assert_instr(vpmovsdb))]
14147pub fn _mm_cvtsepi32_epi8(a: __m128i) -> __m128i {
14148 unsafe { transmute(vpmovsdb128(a.as_i32x4(), i8x16::ZERO, 0b11111111)) }
14149}
14150
14151#[inline]
14155#[target_feature(enable = "avx512f,avx512vl")]
14156#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14157#[cfg_attr(test, assert_instr(vpmovsdb))]
14158pub fn _mm_mask_cvtsepi32_epi8(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14159 unsafe { transmute(vpmovsdb128(a.as_i32x4(), src.as_i8x16(), k)) }
14160}
14161
14162#[inline]
14166#[target_feature(enable = "avx512f,avx512vl")]
14167#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14168#[cfg_attr(test, assert_instr(vpmovsdb))]
14169pub fn _mm_maskz_cvtsepi32_epi8(k: __mmask8, a: __m128i) -> __m128i {
14170 unsafe { transmute(vpmovsdb128(a.as_i32x4(), i8x16::ZERO, k)) }
14171}
14172
14173#[inline]
14177#[target_feature(enable = "avx512f")]
14178#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14179#[cfg_attr(test, assert_instr(vpmovsqd))]
14180pub fn _mm512_cvtsepi64_epi32(a: __m512i) -> __m256i {
14181 unsafe { transmute(vpmovsqd(a.as_i64x8(), i32x8::ZERO, 0b11111111)) }
14182}
14183
14184#[inline]
14188#[target_feature(enable = "avx512f")]
14189#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14190#[cfg_attr(test, assert_instr(vpmovsqd))]
14191pub fn _mm512_mask_cvtsepi64_epi32(src: __m256i, k: __mmask8, a: __m512i) -> __m256i {
14192 unsafe { transmute(vpmovsqd(a.as_i64x8(), src.as_i32x8(), k)) }
14193}
14194
14195#[inline]
14199#[target_feature(enable = "avx512f")]
14200#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14201#[cfg_attr(test, assert_instr(vpmovsqd))]
14202pub fn _mm512_maskz_cvtsepi64_epi32(k: __mmask8, a: __m512i) -> __m256i {
14203 unsafe { transmute(vpmovsqd(a.as_i64x8(), i32x8::ZERO, k)) }
14204}
14205
14206#[inline]
14210#[target_feature(enable = "avx512f,avx512vl")]
14211#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14212#[cfg_attr(test, assert_instr(vpmovsqd))]
14213pub fn _mm256_cvtsepi64_epi32(a: __m256i) -> __m128i {
14214 unsafe { transmute(vpmovsqd256(a.as_i64x4(), i32x4::ZERO, 0b11111111)) }
14215}
14216
14217#[inline]
14221#[target_feature(enable = "avx512f,avx512vl")]
14222#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14223#[cfg_attr(test, assert_instr(vpmovsqd))]
14224pub fn _mm256_mask_cvtsepi64_epi32(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14225 unsafe { transmute(vpmovsqd256(a.as_i64x4(), src.as_i32x4(), k)) }
14226}
14227
14228#[inline]
14232#[target_feature(enable = "avx512f,avx512vl")]
14233#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14234#[cfg_attr(test, assert_instr(vpmovsqd))]
14235pub fn _mm256_maskz_cvtsepi64_epi32(k: __mmask8, a: __m256i) -> __m128i {
14236 unsafe { transmute(vpmovsqd256(a.as_i64x4(), i32x4::ZERO, k)) }
14237}
14238
14239#[inline]
14243#[target_feature(enable = "avx512f,avx512vl")]
14244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14245#[cfg_attr(test, assert_instr(vpmovsqd))]
14246pub fn _mm_cvtsepi64_epi32(a: __m128i) -> __m128i {
14247 unsafe { transmute(vpmovsqd128(a.as_i64x2(), i32x4::ZERO, 0b11111111)) }
14248}
14249
14250#[inline]
14254#[target_feature(enable = "avx512f,avx512vl")]
14255#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14256#[cfg_attr(test, assert_instr(vpmovsqd))]
14257pub fn _mm_mask_cvtsepi64_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14258 unsafe { transmute(vpmovsqd128(a.as_i64x2(), src.as_i32x4(), k)) }
14259}
14260
14261#[inline]
14265#[target_feature(enable = "avx512f,avx512vl")]
14266#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14267#[cfg_attr(test, assert_instr(vpmovsqd))]
14268pub fn _mm_maskz_cvtsepi64_epi32(k: __mmask8, a: __m128i) -> __m128i {
14269 unsafe { transmute(vpmovsqd128(a.as_i64x2(), i32x4::ZERO, k)) }
14270}
14271
14272#[inline]
14276#[target_feature(enable = "avx512f")]
14277#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14278#[cfg_attr(test, assert_instr(vpmovsqw))]
14279pub fn _mm512_cvtsepi64_epi16(a: __m512i) -> __m128i {
14280 unsafe { transmute(vpmovsqw(a.as_i64x8(), i16x8::ZERO, 0b11111111)) }
14281}
14282
14283#[inline]
14287#[target_feature(enable = "avx512f")]
14288#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14289#[cfg_attr(test, assert_instr(vpmovsqw))]
14290pub fn _mm512_mask_cvtsepi64_epi16(src: __m128i, k: __mmask8, a: __m512i) -> __m128i {
14291 unsafe { transmute(vpmovsqw(a.as_i64x8(), src.as_i16x8(), k)) }
14292}
14293
14294#[inline]
14298#[target_feature(enable = "avx512f")]
14299#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14300#[cfg_attr(test, assert_instr(vpmovsqw))]
14301pub fn _mm512_maskz_cvtsepi64_epi16(k: __mmask8, a: __m512i) -> __m128i {
14302 unsafe { transmute(vpmovsqw(a.as_i64x8(), i16x8::ZERO, k)) }
14303}
14304
14305#[inline]
14309#[target_feature(enable = "avx512f,avx512vl")]
14310#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14311#[cfg_attr(test, assert_instr(vpmovsqw))]
14312pub fn _mm256_cvtsepi64_epi16(a: __m256i) -> __m128i {
14313 unsafe { transmute(vpmovsqw256(a.as_i64x4(), i16x8::ZERO, 0b11111111)) }
14314}
14315
14316#[inline]
14320#[target_feature(enable = "avx512f,avx512vl")]
14321#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14322#[cfg_attr(test, assert_instr(vpmovsqw))]
14323pub fn _mm256_mask_cvtsepi64_epi16(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14324 unsafe { transmute(vpmovsqw256(a.as_i64x4(), src.as_i16x8(), k)) }
14325}
14326
14327#[inline]
14331#[target_feature(enable = "avx512f,avx512vl")]
14332#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14333#[cfg_attr(test, assert_instr(vpmovsqw))]
14334pub fn _mm256_maskz_cvtsepi64_epi16(k: __mmask8, a: __m256i) -> __m128i {
14335 unsafe { transmute(vpmovsqw256(a.as_i64x4(), i16x8::ZERO, k)) }
14336}
14337
14338#[inline]
14342#[target_feature(enable = "avx512f,avx512vl")]
14343#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14344#[cfg_attr(test, assert_instr(vpmovsqw))]
14345pub fn _mm_cvtsepi64_epi16(a: __m128i) -> __m128i {
14346 unsafe { transmute(vpmovsqw128(a.as_i64x2(), i16x8::ZERO, 0b11111111)) }
14347}
14348
14349#[inline]
14353#[target_feature(enable = "avx512f,avx512vl")]
14354#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14355#[cfg_attr(test, assert_instr(vpmovsqw))]
14356pub fn _mm_mask_cvtsepi64_epi16(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14357 unsafe { transmute(vpmovsqw128(a.as_i64x2(), src.as_i16x8(), k)) }
14358}
14359
14360#[inline]
14364#[target_feature(enable = "avx512f,avx512vl")]
14365#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14366#[cfg_attr(test, assert_instr(vpmovsqw))]
14367pub fn _mm_maskz_cvtsepi64_epi16(k: __mmask8, a: __m128i) -> __m128i {
14368 unsafe { transmute(vpmovsqw128(a.as_i64x2(), i16x8::ZERO, k)) }
14369}
14370
14371#[inline]
14375#[target_feature(enable = "avx512f")]
14376#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14377#[cfg_attr(test, assert_instr(vpmovsqb))]
14378pub fn _mm512_cvtsepi64_epi8(a: __m512i) -> __m128i {
14379 unsafe { transmute(vpmovsqb(a.as_i64x8(), i8x16::ZERO, 0b11111111)) }
14380}
14381
14382#[inline]
14386#[target_feature(enable = "avx512f")]
14387#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14388#[cfg_attr(test, assert_instr(vpmovsqb))]
14389pub fn _mm512_mask_cvtsepi64_epi8(src: __m128i, k: __mmask8, a: __m512i) -> __m128i {
14390 unsafe { transmute(vpmovsqb(a.as_i64x8(), src.as_i8x16(), k)) }
14391}
14392
14393#[inline]
14397#[target_feature(enable = "avx512f")]
14398#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14399#[cfg_attr(test, assert_instr(vpmovsqb))]
14400pub fn _mm512_maskz_cvtsepi64_epi8(k: __mmask8, a: __m512i) -> __m128i {
14401 unsafe { transmute(vpmovsqb(a.as_i64x8(), i8x16::ZERO, k)) }
14402}
14403
14404#[inline]
14408#[target_feature(enable = "avx512f,avx512vl")]
14409#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14410#[cfg_attr(test, assert_instr(vpmovsqb))]
14411pub fn _mm256_cvtsepi64_epi8(a: __m256i) -> __m128i {
14412 unsafe { transmute(vpmovsqb256(a.as_i64x4(), i8x16::ZERO, 0b11111111)) }
14413}
14414
14415#[inline]
14419#[target_feature(enable = "avx512f,avx512vl")]
14420#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14421#[cfg_attr(test, assert_instr(vpmovsqb))]
14422pub fn _mm256_mask_cvtsepi64_epi8(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14423 unsafe { transmute(vpmovsqb256(a.as_i64x4(), src.as_i8x16(), k)) }
14424}
14425
14426#[inline]
14430#[target_feature(enable = "avx512f,avx512vl")]
14431#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14432#[cfg_attr(test, assert_instr(vpmovsqb))]
14433pub fn _mm256_maskz_cvtsepi64_epi8(k: __mmask8, a: __m256i) -> __m128i {
14434 unsafe { transmute(vpmovsqb256(a.as_i64x4(), i8x16::ZERO, k)) }
14435}
14436
14437#[inline]
14441#[target_feature(enable = "avx512f,avx512vl")]
14442#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14443#[cfg_attr(test, assert_instr(vpmovsqb))]
14444pub fn _mm_cvtsepi64_epi8(a: __m128i) -> __m128i {
14445 unsafe { transmute(vpmovsqb128(a.as_i64x2(), i8x16::ZERO, 0b11111111)) }
14446}
14447
14448#[inline]
14452#[target_feature(enable = "avx512f,avx512vl")]
14453#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14454#[cfg_attr(test, assert_instr(vpmovsqb))]
14455pub fn _mm_mask_cvtsepi64_epi8(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14456 unsafe { transmute(vpmovsqb128(a.as_i64x2(), src.as_i8x16(), k)) }
14457}
14458
14459#[inline]
14463#[target_feature(enable = "avx512f,avx512vl")]
14464#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14465#[cfg_attr(test, assert_instr(vpmovsqb))]
14466pub fn _mm_maskz_cvtsepi64_epi8(k: __mmask8, a: __m128i) -> __m128i {
14467 unsafe { transmute(vpmovsqb128(a.as_i64x2(), i8x16::ZERO, k)) }
14468}
14469
14470#[inline]
14474#[target_feature(enable = "avx512f")]
14475#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14476#[cfg_attr(test, assert_instr(vpmovusdw))]
14477pub fn _mm512_cvtusepi32_epi16(a: __m512i) -> __m256i {
14478 unsafe { transmute(vpmovusdw(a.as_u32x16(), u16x16::ZERO, 0b11111111_11111111)) }
14479}
14480
14481#[inline]
14485#[target_feature(enable = "avx512f")]
14486#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14487#[cfg_attr(test, assert_instr(vpmovusdw))]
14488pub fn _mm512_mask_cvtusepi32_epi16(src: __m256i, k: __mmask16, a: __m512i) -> __m256i {
14489 unsafe { transmute(vpmovusdw(a.as_u32x16(), src.as_u16x16(), k)) }
14490}
14491
14492#[inline]
14496#[target_feature(enable = "avx512f")]
14497#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14498#[cfg_attr(test, assert_instr(vpmovusdw))]
14499pub fn _mm512_maskz_cvtusepi32_epi16(k: __mmask16, a: __m512i) -> __m256i {
14500 unsafe { transmute(vpmovusdw(a.as_u32x16(), u16x16::ZERO, k)) }
14501}
14502
14503#[inline]
14507#[target_feature(enable = "avx512f,avx512vl")]
14508#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14509#[cfg_attr(test, assert_instr(vpmovusdw))]
14510pub fn _mm256_cvtusepi32_epi16(a: __m256i) -> __m128i {
14511 unsafe { transmute(vpmovusdw256(a.as_u32x8(), u16x8::ZERO, 0b11111111)) }
14512}
14513
14514#[inline]
14518#[target_feature(enable = "avx512f,avx512vl")]
14519#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14520#[cfg_attr(test, assert_instr(vpmovusdw))]
14521pub fn _mm256_mask_cvtusepi32_epi16(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14522 unsafe { transmute(vpmovusdw256(a.as_u32x8(), src.as_u16x8(), k)) }
14523}
14524
14525#[inline]
14529#[target_feature(enable = "avx512f,avx512vl")]
14530#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14531#[cfg_attr(test, assert_instr(vpmovusdw))]
14532pub fn _mm256_maskz_cvtusepi32_epi16(k: __mmask8, a: __m256i) -> __m128i {
14533 unsafe { transmute(vpmovusdw256(a.as_u32x8(), u16x8::ZERO, k)) }
14534}
14535
14536#[inline]
14540#[target_feature(enable = "avx512f,avx512vl")]
14541#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14542#[cfg_attr(test, assert_instr(vpmovusdw))]
14543pub fn _mm_cvtusepi32_epi16(a: __m128i) -> __m128i {
14544 unsafe { transmute(vpmovusdw128(a.as_u32x4(), u16x8::ZERO, 0b11111111)) }
14545}
14546
14547#[inline]
14551#[target_feature(enable = "avx512f,avx512vl")]
14552#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14553#[cfg_attr(test, assert_instr(vpmovusdw))]
14554pub fn _mm_mask_cvtusepi32_epi16(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14555 unsafe { transmute(vpmovusdw128(a.as_u32x4(), src.as_u16x8(), k)) }
14556}
14557
14558#[inline]
14562#[target_feature(enable = "avx512f,avx512vl")]
14563#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14564#[cfg_attr(test, assert_instr(vpmovusdw))]
14565pub fn _mm_maskz_cvtusepi32_epi16(k: __mmask8, a: __m128i) -> __m128i {
14566 unsafe { transmute(vpmovusdw128(a.as_u32x4(), u16x8::ZERO, k)) }
14567}
14568
14569#[inline]
14573#[target_feature(enable = "avx512f")]
14574#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14575#[cfg_attr(test, assert_instr(vpmovusdb))]
14576pub fn _mm512_cvtusepi32_epi8(a: __m512i) -> __m128i {
14577 unsafe { transmute(vpmovusdb(a.as_u32x16(), u8x16::ZERO, 0b11111111_11111111)) }
14578}
14579
14580#[inline]
14584#[target_feature(enable = "avx512f")]
14585#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14586#[cfg_attr(test, assert_instr(vpmovusdb))]
14587pub fn _mm512_mask_cvtusepi32_epi8(src: __m128i, k: __mmask16, a: __m512i) -> __m128i {
14588 unsafe { transmute(vpmovusdb(a.as_u32x16(), src.as_u8x16(), k)) }
14589}
14590
14591#[inline]
14595#[target_feature(enable = "avx512f")]
14596#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14597#[cfg_attr(test, assert_instr(vpmovusdb))]
14598pub fn _mm512_maskz_cvtusepi32_epi8(k: __mmask16, a: __m512i) -> __m128i {
14599 unsafe { transmute(vpmovusdb(a.as_u32x16(), u8x16::ZERO, k)) }
14600}
14601
14602#[inline]
14606#[target_feature(enable = "avx512f,avx512vl")]
14607#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14608#[cfg_attr(test, assert_instr(vpmovusdb))]
14609pub fn _mm256_cvtusepi32_epi8(a: __m256i) -> __m128i {
14610 unsafe { transmute(vpmovusdb256(a.as_u32x8(), u8x16::ZERO, 0b11111111)) }
14611}
14612
14613#[inline]
14617#[target_feature(enable = "avx512f,avx512vl")]
14618#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14619#[cfg_attr(test, assert_instr(vpmovusdb))]
14620pub fn _mm256_mask_cvtusepi32_epi8(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14621 unsafe { transmute(vpmovusdb256(a.as_u32x8(), src.as_u8x16(), k)) }
14622}
14623
14624#[inline]
14628#[target_feature(enable = "avx512f,avx512vl")]
14629#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14630#[cfg_attr(test, assert_instr(vpmovusdb))]
14631pub fn _mm256_maskz_cvtusepi32_epi8(k: __mmask8, a: __m256i) -> __m128i {
14632 unsafe { transmute(vpmovusdb256(a.as_u32x8(), u8x16::ZERO, k)) }
14633}
14634
14635#[inline]
14639#[target_feature(enable = "avx512f,avx512vl")]
14640#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14641#[cfg_attr(test, assert_instr(vpmovusdb))]
14642pub fn _mm_cvtusepi32_epi8(a: __m128i) -> __m128i {
14643 unsafe { transmute(vpmovusdb128(a.as_u32x4(), u8x16::ZERO, 0b11111111)) }
14644}
14645
14646#[inline]
14650#[target_feature(enable = "avx512f,avx512vl")]
14651#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14652#[cfg_attr(test, assert_instr(vpmovusdb))]
14653pub fn _mm_mask_cvtusepi32_epi8(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14654 unsafe { transmute(vpmovusdb128(a.as_u32x4(), src.as_u8x16(), k)) }
14655}
14656
14657#[inline]
14661#[target_feature(enable = "avx512f,avx512vl")]
14662#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14663#[cfg_attr(test, assert_instr(vpmovusdb))]
14664pub fn _mm_maskz_cvtusepi32_epi8(k: __mmask8, a: __m128i) -> __m128i {
14665 unsafe { transmute(vpmovusdb128(a.as_u32x4(), u8x16::ZERO, k)) }
14666}
14667
14668#[inline]
14672#[target_feature(enable = "avx512f")]
14673#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14674#[cfg_attr(test, assert_instr(vpmovusqd))]
14675pub fn _mm512_cvtusepi64_epi32(a: __m512i) -> __m256i {
14676 unsafe { transmute(vpmovusqd(a.as_u64x8(), u32x8::ZERO, 0b11111111)) }
14677}
14678
14679#[inline]
14683#[target_feature(enable = "avx512f")]
14684#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14685#[cfg_attr(test, assert_instr(vpmovusqd))]
14686pub fn _mm512_mask_cvtusepi64_epi32(src: __m256i, k: __mmask8, a: __m512i) -> __m256i {
14687 unsafe { transmute(vpmovusqd(a.as_u64x8(), src.as_u32x8(), k)) }
14688}
14689
14690#[inline]
14694#[target_feature(enable = "avx512f")]
14695#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14696#[cfg_attr(test, assert_instr(vpmovusqd))]
14697pub fn _mm512_maskz_cvtusepi64_epi32(k: __mmask8, a: __m512i) -> __m256i {
14698 unsafe { transmute(vpmovusqd(a.as_u64x8(), u32x8::ZERO, k)) }
14699}
14700
14701#[inline]
14705#[target_feature(enable = "avx512f,avx512vl")]
14706#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14707#[cfg_attr(test, assert_instr(vpmovusqd))]
14708pub fn _mm256_cvtusepi64_epi32(a: __m256i) -> __m128i {
14709 unsafe { transmute(vpmovusqd256(a.as_u64x4(), u32x4::ZERO, 0b11111111)) }
14710}
14711
14712#[inline]
14716#[target_feature(enable = "avx512f,avx512vl")]
14717#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14718#[cfg_attr(test, assert_instr(vpmovusqd))]
14719pub fn _mm256_mask_cvtusepi64_epi32(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14720 unsafe { transmute(vpmovusqd256(a.as_u64x4(), src.as_u32x4(), k)) }
14721}
14722
14723#[inline]
14727#[target_feature(enable = "avx512f,avx512vl")]
14728#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14729#[cfg_attr(test, assert_instr(vpmovusqd))]
14730pub fn _mm256_maskz_cvtusepi64_epi32(k: __mmask8, a: __m256i) -> __m128i {
14731 unsafe { transmute(vpmovusqd256(a.as_u64x4(), u32x4::ZERO, k)) }
14732}
14733
14734#[inline]
14738#[target_feature(enable = "avx512f,avx512vl")]
14739#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14740#[cfg_attr(test, assert_instr(vpmovusqd))]
14741pub fn _mm_cvtusepi64_epi32(a: __m128i) -> __m128i {
14742 unsafe { transmute(vpmovusqd128(a.as_u64x2(), u32x4::ZERO, 0b11111111)) }
14743}
14744
14745#[inline]
14749#[target_feature(enable = "avx512f,avx512vl")]
14750#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14751#[cfg_attr(test, assert_instr(vpmovusqd))]
14752pub fn _mm_mask_cvtusepi64_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14753 unsafe { transmute(vpmovusqd128(a.as_u64x2(), src.as_u32x4(), k)) }
14754}
14755
14756#[inline]
14760#[target_feature(enable = "avx512f,avx512vl")]
14761#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14762#[cfg_attr(test, assert_instr(vpmovusqd))]
14763pub fn _mm_maskz_cvtusepi64_epi32(k: __mmask8, a: __m128i) -> __m128i {
14764 unsafe { transmute(vpmovusqd128(a.as_u64x2(), u32x4::ZERO, k)) }
14765}
14766
14767#[inline]
14771#[target_feature(enable = "avx512f")]
14772#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14773#[cfg_attr(test, assert_instr(vpmovusqw))]
14774pub fn _mm512_cvtusepi64_epi16(a: __m512i) -> __m128i {
14775 unsafe { transmute(vpmovusqw(a.as_u64x8(), u16x8::ZERO, 0b11111111)) }
14776}
14777
14778#[inline]
14782#[target_feature(enable = "avx512f")]
14783#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14784#[cfg_attr(test, assert_instr(vpmovusqw))]
14785pub fn _mm512_mask_cvtusepi64_epi16(src: __m128i, k: __mmask8, a: __m512i) -> __m128i {
14786 unsafe { transmute(vpmovusqw(a.as_u64x8(), src.as_u16x8(), k)) }
14787}
14788
14789#[inline]
14793#[target_feature(enable = "avx512f")]
14794#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14795#[cfg_attr(test, assert_instr(vpmovusqw))]
14796pub fn _mm512_maskz_cvtusepi64_epi16(k: __mmask8, a: __m512i) -> __m128i {
14797 unsafe { transmute(vpmovusqw(a.as_u64x8(), u16x8::ZERO, k)) }
14798}
14799
14800#[inline]
14804#[target_feature(enable = "avx512f,avx512vl")]
14805#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14806#[cfg_attr(test, assert_instr(vpmovusqw))]
14807pub fn _mm256_cvtusepi64_epi16(a: __m256i) -> __m128i {
14808 unsafe { transmute(vpmovusqw256(a.as_u64x4(), u16x8::ZERO, 0b11111111)) }
14809}
14810
14811#[inline]
14815#[target_feature(enable = "avx512f,avx512vl")]
14816#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14817#[cfg_attr(test, assert_instr(vpmovusqw))]
14818pub fn _mm256_mask_cvtusepi64_epi16(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14819 unsafe { transmute(vpmovusqw256(a.as_u64x4(), src.as_u16x8(), k)) }
14820}
14821
14822#[inline]
14826#[target_feature(enable = "avx512f,avx512vl")]
14827#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14828#[cfg_attr(test, assert_instr(vpmovusqw))]
14829pub fn _mm256_maskz_cvtusepi64_epi16(k: __mmask8, a: __m256i) -> __m128i {
14830 unsafe { transmute(vpmovusqw256(a.as_u64x4(), u16x8::ZERO, k)) }
14831}
14832
14833#[inline]
14837#[target_feature(enable = "avx512f,avx512vl")]
14838#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14839#[cfg_attr(test, assert_instr(vpmovusqw))]
14840pub fn _mm_cvtusepi64_epi16(a: __m128i) -> __m128i {
14841 unsafe { transmute(vpmovusqw128(a.as_u64x2(), u16x8::ZERO, 0b11111111)) }
14842}
14843
14844#[inline]
14848#[target_feature(enable = "avx512f,avx512vl")]
14849#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14850#[cfg_attr(test, assert_instr(vpmovusqw))]
14851pub fn _mm_mask_cvtusepi64_epi16(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14852 unsafe { transmute(vpmovusqw128(a.as_u64x2(), src.as_u16x8(), k)) }
14853}
14854
14855#[inline]
14859#[target_feature(enable = "avx512f,avx512vl")]
14860#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14861#[cfg_attr(test, assert_instr(vpmovusqw))]
14862pub fn _mm_maskz_cvtusepi64_epi16(k: __mmask8, a: __m128i) -> __m128i {
14863 unsafe { transmute(vpmovusqw128(a.as_u64x2(), u16x8::ZERO, k)) }
14864}
14865
14866#[inline]
14870#[target_feature(enable = "avx512f")]
14871#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14872#[cfg_attr(test, assert_instr(vpmovusqb))]
14873pub fn _mm512_cvtusepi64_epi8(a: __m512i) -> __m128i {
14874 unsafe { transmute(vpmovusqb(a.as_u64x8(), u8x16::ZERO, 0b11111111)) }
14875}
14876
14877#[inline]
14881#[target_feature(enable = "avx512f")]
14882#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14883#[cfg_attr(test, assert_instr(vpmovusqb))]
14884pub fn _mm512_mask_cvtusepi64_epi8(src: __m128i, k: __mmask8, a: __m512i) -> __m128i {
14885 unsafe { transmute(vpmovusqb(a.as_u64x8(), src.as_u8x16(), k)) }
14886}
14887
14888#[inline]
14892#[target_feature(enable = "avx512f")]
14893#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14894#[cfg_attr(test, assert_instr(vpmovusqb))]
14895pub fn _mm512_maskz_cvtusepi64_epi8(k: __mmask8, a: __m512i) -> __m128i {
14896 unsafe { transmute(vpmovusqb(a.as_u64x8(), u8x16::ZERO, k)) }
14897}
14898
14899#[inline]
14903#[target_feature(enable = "avx512f,avx512vl")]
14904#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14905#[cfg_attr(test, assert_instr(vpmovusqb))]
14906pub fn _mm256_cvtusepi64_epi8(a: __m256i) -> __m128i {
14907 unsafe { transmute(vpmovusqb256(a.as_u64x4(), u8x16::ZERO, 0b11111111)) }
14908}
14909
14910#[inline]
14914#[target_feature(enable = "avx512f,avx512vl")]
14915#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14916#[cfg_attr(test, assert_instr(vpmovusqb))]
14917pub fn _mm256_mask_cvtusepi64_epi8(src: __m128i, k: __mmask8, a: __m256i) -> __m128i {
14918 unsafe { transmute(vpmovusqb256(a.as_u64x4(), src.as_u8x16(), k)) }
14919}
14920
14921#[inline]
14925#[target_feature(enable = "avx512f,avx512vl")]
14926#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14927#[cfg_attr(test, assert_instr(vpmovusqb))]
14928pub fn _mm256_maskz_cvtusepi64_epi8(k: __mmask8, a: __m256i) -> __m128i {
14929 unsafe { transmute(vpmovusqb256(a.as_u64x4(), u8x16::ZERO, k)) }
14930}
14931
14932#[inline]
14936#[target_feature(enable = "avx512f,avx512vl")]
14937#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14938#[cfg_attr(test, assert_instr(vpmovusqb))]
14939pub fn _mm_cvtusepi64_epi8(a: __m128i) -> __m128i {
14940 unsafe { transmute(vpmovusqb128(a.as_u64x2(), u8x16::ZERO, 0b11111111)) }
14941}
14942
14943#[inline]
14947#[target_feature(enable = "avx512f,avx512vl")]
14948#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14949#[cfg_attr(test, assert_instr(vpmovusqb))]
14950pub fn _mm_mask_cvtusepi64_epi8(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
14951 unsafe { transmute(vpmovusqb128(a.as_u64x2(), src.as_u8x16(), k)) }
14952}
14953
14954#[inline]
14958#[target_feature(enable = "avx512f,avx512vl")]
14959#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14960#[cfg_attr(test, assert_instr(vpmovusqb))]
14961pub fn _mm_maskz_cvtusepi64_epi8(k: __mmask8, a: __m128i) -> __m128i {
14962 unsafe { transmute(vpmovusqb128(a.as_u64x2(), u8x16::ZERO, k)) }
14963}
14964
14965#[inline]
14976#[target_feature(enable = "avx512f")]
14977#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
14978#[cfg_attr(test, assert_instr(vcvtps2dq, ROUNDING = 8))]
14979#[rustc_legacy_const_generics(1)]
14980pub fn _mm512_cvt_roundps_epi32<const ROUNDING: i32>(a: __m512) -> __m512i {
14981 unsafe {
14982 static_assert_rounding!(ROUNDING);
14983 let a = a.as_f32x16();
14984 let r = vcvtps2dq(a, i32x16::ZERO, 0b11111111_11111111, ROUNDING);
14985 transmute(r)
14986 }
14987}
14988
14989#[inline]
15000#[target_feature(enable = "avx512f")]
15001#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15002#[cfg_attr(test, assert_instr(vcvtps2dq, ROUNDING = 8))]
15003#[rustc_legacy_const_generics(3)]
15004pub fn _mm512_mask_cvt_roundps_epi32<const ROUNDING: i32>(
15005 src: __m512i,
15006 k: __mmask16,
15007 a: __m512,
15008) -> __m512i {
15009 unsafe {
15010 static_assert_rounding!(ROUNDING);
15011 let a = a.as_f32x16();
15012 let src = src.as_i32x16();
15013 let r = vcvtps2dq(a, src, k, ROUNDING);
15014 transmute(r)
15015 }
15016}
15017
15018#[inline]
15029#[target_feature(enable = "avx512f")]
15030#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15031#[cfg_attr(test, assert_instr(vcvtps2dq, ROUNDING = 8))]
15032#[rustc_legacy_const_generics(2)]
15033pub fn _mm512_maskz_cvt_roundps_epi32<const ROUNDING: i32>(k: __mmask16, a: __m512) -> __m512i {
15034 unsafe {
15035 static_assert_rounding!(ROUNDING);
15036 let a = a.as_f32x16();
15037 let r = vcvtps2dq(a, i32x16::ZERO, k, ROUNDING);
15038 transmute(r)
15039 }
15040}
15041
15042#[inline]
15053#[target_feature(enable = "avx512f")]
15054#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15055#[cfg_attr(test, assert_instr(vcvtps2udq, ROUNDING = 8))]
15056#[rustc_legacy_const_generics(1)]
15057pub fn _mm512_cvt_roundps_epu32<const ROUNDING: i32>(a: __m512) -> __m512i {
15058 unsafe {
15059 static_assert_rounding!(ROUNDING);
15060 let a = a.as_f32x16();
15061 let r = vcvtps2udq(a, u32x16::ZERO, 0b11111111_11111111, ROUNDING);
15062 transmute(r)
15063 }
15064}
15065
15066#[inline]
15077#[target_feature(enable = "avx512f")]
15078#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15079#[cfg_attr(test, assert_instr(vcvtps2udq, ROUNDING = 8))]
15080#[rustc_legacy_const_generics(3)]
15081pub fn _mm512_mask_cvt_roundps_epu32<const ROUNDING: i32>(
15082 src: __m512i,
15083 k: __mmask16,
15084 a: __m512,
15085) -> __m512i {
15086 unsafe {
15087 static_assert_rounding!(ROUNDING);
15088 let a = a.as_f32x16();
15089 let src = src.as_u32x16();
15090 let r = vcvtps2udq(a, src, k, ROUNDING);
15091 transmute(r)
15092 }
15093}
15094
15095#[inline]
15106#[target_feature(enable = "avx512f")]
15107#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15108#[cfg_attr(test, assert_instr(vcvtps2udq, ROUNDING = 8))]
15109#[rustc_legacy_const_generics(2)]
15110pub fn _mm512_maskz_cvt_roundps_epu32<const ROUNDING: i32>(k: __mmask16, a: __m512) -> __m512i {
15111 unsafe {
15112 static_assert_rounding!(ROUNDING);
15113 let a = a.as_f32x16();
15114 let r = vcvtps2udq(a, u32x16::ZERO, k, ROUNDING);
15115 transmute(r)
15116 }
15117}
15118
15119#[inline]
15124#[target_feature(enable = "avx512f")]
15125#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15126#[cfg_attr(test, assert_instr(vcvtps2pd, SAE = 8))]
15127#[rustc_legacy_const_generics(1)]
15128pub fn _mm512_cvt_roundps_pd<const SAE: i32>(a: __m256) -> __m512d {
15129 unsafe {
15130 static_assert_sae!(SAE);
15131 let a = a.as_f32x8();
15132 let r = vcvtps2pd(a, f64x8::ZERO, 0b11111111, SAE);
15133 transmute(r)
15134 }
15135}
15136
15137#[inline]
15142#[target_feature(enable = "avx512f")]
15143#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15144#[cfg_attr(test, assert_instr(vcvtps2pd, SAE = 8))]
15145#[rustc_legacy_const_generics(3)]
15146pub fn _mm512_mask_cvt_roundps_pd<const SAE: i32>(src: __m512d, k: __mmask8, a: __m256) -> __m512d {
15147 unsafe {
15148 static_assert_sae!(SAE);
15149 let a = a.as_f32x8();
15150 let src = src.as_f64x8();
15151 let r = vcvtps2pd(a, src, k, SAE);
15152 transmute(r)
15153 }
15154}
15155
15156#[inline]
15161#[target_feature(enable = "avx512f")]
15162#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15163#[cfg_attr(test, assert_instr(vcvtps2pd, SAE = 8))]
15164#[rustc_legacy_const_generics(2)]
15165pub fn _mm512_maskz_cvt_roundps_pd<const SAE: i32>(k: __mmask8, a: __m256) -> __m512d {
15166 unsafe {
15167 static_assert_sae!(SAE);
15168 let a = a.as_f32x8();
15169 let r = vcvtps2pd(a, f64x8::ZERO, k, SAE);
15170 transmute(r)
15171 }
15172}
15173
15174#[inline]
15185#[target_feature(enable = "avx512f")]
15186#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15187#[cfg_attr(test, assert_instr(vcvtpd2dq, ROUNDING = 8))]
15188#[rustc_legacy_const_generics(1)]
15189pub fn _mm512_cvt_roundpd_epi32<const ROUNDING: i32>(a: __m512d) -> __m256i {
15190 unsafe {
15191 static_assert_rounding!(ROUNDING);
15192 let a = a.as_f64x8();
15193 let r = vcvtpd2dq(a, i32x8::ZERO, 0b11111111, ROUNDING);
15194 transmute(r)
15195 }
15196}
15197
15198#[inline]
15209#[target_feature(enable = "avx512f")]
15210#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15211#[cfg_attr(test, assert_instr(vcvtpd2dq, ROUNDING = 8))]
15212#[rustc_legacy_const_generics(3)]
15213pub fn _mm512_mask_cvt_roundpd_epi32<const ROUNDING: i32>(
15214 src: __m256i,
15215 k: __mmask8,
15216 a: __m512d,
15217) -> __m256i {
15218 unsafe {
15219 static_assert_rounding!(ROUNDING);
15220 let a = a.as_f64x8();
15221 let src = src.as_i32x8();
15222 let r = vcvtpd2dq(a, src, k, ROUNDING);
15223 transmute(r)
15224 }
15225}
15226
15227#[inline]
15238#[target_feature(enable = "avx512f")]
15239#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15240#[cfg_attr(test, assert_instr(vcvtpd2dq, ROUNDING = 8))]
15241#[rustc_legacy_const_generics(2)]
15242pub fn _mm512_maskz_cvt_roundpd_epi32<const ROUNDING: i32>(k: __mmask8, a: __m512d) -> __m256i {
15243 unsafe {
15244 static_assert_rounding!(ROUNDING);
15245 let a = a.as_f64x8();
15246 let r = vcvtpd2dq(a, i32x8::ZERO, k, ROUNDING);
15247 transmute(r)
15248 }
15249}
15250
15251#[inline]
15262#[target_feature(enable = "avx512f")]
15263#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15264#[cfg_attr(test, assert_instr(vcvtpd2udq, ROUNDING = 8))]
15265#[rustc_legacy_const_generics(1)]
15266pub fn _mm512_cvt_roundpd_epu32<const ROUNDING: i32>(a: __m512d) -> __m256i {
15267 unsafe {
15268 static_assert_rounding!(ROUNDING);
15269 let a = a.as_f64x8();
15270 let r = vcvtpd2udq(a, u32x8::ZERO, 0b11111111, ROUNDING);
15271 transmute(r)
15272 }
15273}
15274
15275#[inline]
15286#[target_feature(enable = "avx512f")]
15287#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15288#[cfg_attr(test, assert_instr(vcvtpd2udq, ROUNDING = 8))]
15289#[rustc_legacy_const_generics(3)]
15290pub fn _mm512_mask_cvt_roundpd_epu32<const ROUNDING: i32>(
15291 src: __m256i,
15292 k: __mmask8,
15293 a: __m512d,
15294) -> __m256i {
15295 unsafe {
15296 static_assert_rounding!(ROUNDING);
15297 let a = a.as_f64x8();
15298 let src = src.as_u32x8();
15299 let r = vcvtpd2udq(a, src, k, ROUNDING);
15300 transmute(r)
15301 }
15302}
15303
15304#[inline]
15315#[target_feature(enable = "avx512f")]
15316#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15317#[cfg_attr(test, assert_instr(vcvtpd2udq, ROUNDING = 8))]
15318#[rustc_legacy_const_generics(2)]
15319pub fn _mm512_maskz_cvt_roundpd_epu32<const ROUNDING: i32>(k: __mmask8, a: __m512d) -> __m256i {
15320 unsafe {
15321 static_assert_rounding!(ROUNDING);
15322 let a = a.as_f64x8();
15323 let r = vcvtpd2udq(a, u32x8::ZERO, k, ROUNDING);
15324 transmute(r)
15325 }
15326}
15327
15328#[inline]
15339#[target_feature(enable = "avx512f")]
15340#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15341#[cfg_attr(test, assert_instr(vcvtpd2ps, ROUNDING = 8))]
15342#[rustc_legacy_const_generics(1)]
15343pub fn _mm512_cvt_roundpd_ps<const ROUNDING: i32>(a: __m512d) -> __m256 {
15344 unsafe {
15345 static_assert_rounding!(ROUNDING);
15346 let a = a.as_f64x8();
15347 let r = vcvtpd2ps(a, f32x8::ZERO, 0b11111111, ROUNDING);
15348 transmute(r)
15349 }
15350}
15351
15352#[inline]
15363#[target_feature(enable = "avx512f")]
15364#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15365#[cfg_attr(test, assert_instr(vcvtpd2ps, ROUNDING = 8))]
15366#[rustc_legacy_const_generics(3)]
15367pub fn _mm512_mask_cvt_roundpd_ps<const ROUNDING: i32>(
15368 src: __m256,
15369 k: __mmask8,
15370 a: __m512d,
15371) -> __m256 {
15372 unsafe {
15373 static_assert_rounding!(ROUNDING);
15374 let a = a.as_f64x8();
15375 let src = src.as_f32x8();
15376 let r = vcvtpd2ps(a, src, k, ROUNDING);
15377 transmute(r)
15378 }
15379}
15380
15381#[inline]
15392#[target_feature(enable = "avx512f")]
15393#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15394#[cfg_attr(test, assert_instr(vcvtpd2ps, ROUNDING = 8))]
15395#[rustc_legacy_const_generics(2)]
15396pub fn _mm512_maskz_cvt_roundpd_ps<const ROUNDING: i32>(k: __mmask8, a: __m512d) -> __m256 {
15397 unsafe {
15398 static_assert_rounding!(ROUNDING);
15399 let a = a.as_f64x8();
15400 let r = vcvtpd2ps(a, f32x8::ZERO, k, ROUNDING);
15401 transmute(r)
15402 }
15403}
15404
15405#[inline]
15416#[target_feature(enable = "avx512f")]
15417#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15418#[cfg_attr(test, assert_instr(vcvtdq2ps, ROUNDING = 8))]
15419#[rustc_legacy_const_generics(1)]
15420pub fn _mm512_cvt_roundepi32_ps<const ROUNDING: i32>(a: __m512i) -> __m512 {
15421 unsafe {
15422 static_assert_rounding!(ROUNDING);
15423 let a = a.as_i32x16();
15424 let r = vcvtdq2ps(a, ROUNDING);
15425 transmute(r)
15426 }
15427}
15428
15429#[inline]
15440#[target_feature(enable = "avx512f")]
15441#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15442#[cfg_attr(test, assert_instr(vcvtdq2ps, ROUNDING = 8))]
15443#[rustc_legacy_const_generics(3)]
15444pub fn _mm512_mask_cvt_roundepi32_ps<const ROUNDING: i32>(
15445 src: __m512,
15446 k: __mmask16,
15447 a: __m512i,
15448) -> __m512 {
15449 unsafe {
15450 static_assert_rounding!(ROUNDING);
15451 let a = a.as_i32x16();
15452 let r = vcvtdq2ps(a, ROUNDING);
15453 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
15454 }
15455}
15456
15457#[inline]
15468#[target_feature(enable = "avx512f")]
15469#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15470#[cfg_attr(test, assert_instr(vcvtdq2ps, ROUNDING = 8))]
15471#[rustc_legacy_const_generics(2)]
15472pub fn _mm512_maskz_cvt_roundepi32_ps<const ROUNDING: i32>(k: __mmask16, a: __m512i) -> __m512 {
15473 unsafe {
15474 static_assert_rounding!(ROUNDING);
15475 let a = a.as_i32x16();
15476 let r = vcvtdq2ps(a, ROUNDING);
15477 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
15478 }
15479}
15480
15481#[inline]
15492#[target_feature(enable = "avx512f")]
15493#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15494#[cfg_attr(test, assert_instr(vcvtudq2ps, ROUNDING = 8))]
15495#[rustc_legacy_const_generics(1)]
15496pub fn _mm512_cvt_roundepu32_ps<const ROUNDING: i32>(a: __m512i) -> __m512 {
15497 unsafe {
15498 static_assert_rounding!(ROUNDING);
15499 let a = a.as_u32x16();
15500 let r = vcvtudq2ps(a, ROUNDING);
15501 transmute(r)
15502 }
15503}
15504
15505#[inline]
15516#[target_feature(enable = "avx512f")]
15517#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15518#[cfg_attr(test, assert_instr(vcvtudq2ps, ROUNDING = 8))]
15519#[rustc_legacy_const_generics(3)]
15520pub fn _mm512_mask_cvt_roundepu32_ps<const ROUNDING: i32>(
15521 src: __m512,
15522 k: __mmask16,
15523 a: __m512i,
15524) -> __m512 {
15525 unsafe {
15526 static_assert_rounding!(ROUNDING);
15527 let a = a.as_u32x16();
15528 let r = vcvtudq2ps(a, ROUNDING);
15529 transmute(simd_select_bitmask(k, r, src.as_f32x16()))
15530 }
15531}
15532
15533#[inline]
15544#[target_feature(enable = "avx512f")]
15545#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15546#[cfg_attr(test, assert_instr(vcvtudq2ps, ROUNDING = 8))]
15547#[rustc_legacy_const_generics(2)]
15548pub fn _mm512_maskz_cvt_roundepu32_ps<const ROUNDING: i32>(k: __mmask16, a: __m512i) -> __m512 {
15549 unsafe {
15550 static_assert_rounding!(ROUNDING);
15551 let a = a.as_u32x16();
15552 let r = vcvtudq2ps(a, ROUNDING);
15553 transmute(simd_select_bitmask(k, r, f32x16::ZERO))
15554 }
15555}
15556
15557#[inline]
15572#[target_feature(enable = "avx512f")]
15573#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15574#[cfg_attr(test, assert_instr(vcvtps2ph, ROUNDING = 8))]
15575#[rustc_legacy_const_generics(1)]
15576pub fn _mm512_cvt_roundps_ph<const ROUNDING: i32>(a: __m512) -> __m256i {
15577 unsafe {
15578 static_assert_extended_rounding!(ROUNDING);
15579 let a = a.as_f32x16();
15580 let r = vcvtps2ph(a, ROUNDING, i16x16::ZERO, 0b11111111_11111111);
15581 transmute(r)
15582 }
15583}
15584
15585#[inline]
15600#[target_feature(enable = "avx512f")]
15601#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15602#[cfg_attr(test, assert_instr(vcvtps2ph, ROUNDING = 8))]
15603#[rustc_legacy_const_generics(3)]
15604pub fn _mm512_mask_cvt_roundps_ph<const ROUNDING: i32>(
15605 src: __m256i,
15606 k: __mmask16,
15607 a: __m512,
15608) -> __m256i {
15609 unsafe {
15610 static_assert_extended_rounding!(ROUNDING);
15611 let a = a.as_f32x16();
15612 let src = src.as_i16x16();
15613 let r = vcvtps2ph(a, ROUNDING, src, k);
15614 transmute(r)
15615 }
15616}
15617
15618#[inline]
15633#[target_feature(enable = "avx512f")]
15634#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15635#[cfg_attr(test, assert_instr(vcvtps2ph, ROUNDING = 8))]
15636#[rustc_legacy_const_generics(2)]
15637pub fn _mm512_maskz_cvt_roundps_ph<const ROUNDING: i32>(k: __mmask16, a: __m512) -> __m256i {
15638 unsafe {
15639 static_assert_extended_rounding!(ROUNDING);
15640 let a = a.as_f32x16();
15641 let r = vcvtps2ph(a, ROUNDING, i16x16::ZERO, k);
15642 transmute(r)
15643 }
15644}
15645
15646#[inline]
15656#[target_feature(enable = "avx512f,avx512vl")]
15657#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15658#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15659#[rustc_legacy_const_generics(3)]
15660pub fn _mm256_mask_cvt_roundps_ph<const IMM8: i32>(
15661 src: __m128i,
15662 k: __mmask8,
15663 a: __m256,
15664) -> __m128i {
15665 unsafe {
15666 static_assert_round_mode!(IMM8);
15667 let a = a.as_f32x8();
15668 let src = src.as_i16x8();
15669 let r = vcvtps2ph256(a, IMM8, src, k);
15670 transmute(r)
15671 }
15672}
15673
15674#[inline]
15684#[target_feature(enable = "avx512f,avx512vl")]
15685#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15686#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15687#[rustc_legacy_const_generics(2)]
15688pub fn _mm256_maskz_cvt_roundps_ph<const IMM8: i32>(k: __mmask8, a: __m256) -> __m128i {
15689 unsafe {
15690 static_assert_round_mode!(IMM8);
15691 let a = a.as_f32x8();
15692 let r = vcvtps2ph256(a, IMM8, i16x8::ZERO, k);
15693 transmute(r)
15694 }
15695}
15696
15697#[inline]
15707#[target_feature(enable = "avx512f,avx512vl")]
15708#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15709#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15710#[rustc_legacy_const_generics(3)]
15711pub fn _mm_mask_cvt_roundps_ph<const IMM8: i32>(src: __m128i, k: __mmask8, a: __m128) -> __m128i {
15712 unsafe {
15713 static_assert_round_mode!(IMM8);
15714 let a = a.as_f32x4();
15715 let src = src.as_i16x8();
15716 let r = vcvtps2ph128(a, IMM8, src, k);
15717 transmute(r)
15718 }
15719}
15720
15721#[inline]
15731#[target_feature(enable = "avx512f,avx512vl")]
15732#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15733#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15734#[rustc_legacy_const_generics(2)]
15735pub fn _mm_maskz_cvt_roundps_ph<const IMM8: i32>(k: __mmask8, a: __m128) -> __m128i {
15736 unsafe {
15737 static_assert_round_mode!(IMM8);
15738 let a = a.as_f32x4();
15739 let r = vcvtps2ph128(a, IMM8, i16x8::ZERO, k);
15740 transmute(r)
15741 }
15742}
15743
15744#[inline]
15759#[target_feature(enable = "avx512f")]
15760#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15761#[cfg_attr(test, assert_instr(vcvtps2ph, ROUNDING = 8))]
15762#[rustc_legacy_const_generics(1)]
15763pub fn _mm512_cvtps_ph<const ROUNDING: i32>(a: __m512) -> __m256i {
15764 unsafe {
15765 static_assert_extended_rounding!(ROUNDING);
15766 let a = a.as_f32x16();
15767 let r = vcvtps2ph(a, ROUNDING, i16x16::ZERO, 0b11111111_11111111);
15768 transmute(r)
15769 }
15770}
15771
15772#[inline]
15787#[target_feature(enable = "avx512f")]
15788#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15789#[cfg_attr(test, assert_instr(vcvtps2ph, ROUNDING = 8))]
15790#[rustc_legacy_const_generics(3)]
15791pub fn _mm512_mask_cvtps_ph<const ROUNDING: i32>(src: __m256i, k: __mmask16, a: __m512) -> __m256i {
15792 unsafe {
15793 static_assert_extended_rounding!(ROUNDING);
15794 let a = a.as_f32x16();
15795 let src = src.as_i16x16();
15796 let r = vcvtps2ph(a, ROUNDING, src, k);
15797 transmute(r)
15798 }
15799}
15800
15801#[inline]
15816#[target_feature(enable = "avx512f")]
15817#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15818#[cfg_attr(test, assert_instr(vcvtps2ph, ROUNDING = 8))]
15819#[rustc_legacy_const_generics(2)]
15820pub fn _mm512_maskz_cvtps_ph<const ROUNDING: i32>(k: __mmask16, a: __m512) -> __m256i {
15821 unsafe {
15822 static_assert_extended_rounding!(ROUNDING);
15823 let a = a.as_f32x16();
15824 let r = vcvtps2ph(a, ROUNDING, i16x16::ZERO, k);
15825 transmute(r)
15826 }
15827}
15828
15829#[inline]
15839#[target_feature(enable = "avx512f,avx512vl")]
15840#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15841#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15842#[rustc_legacy_const_generics(3)]
15843pub fn _mm256_mask_cvtps_ph<const IMM8: i32>(src: __m128i, k: __mmask8, a: __m256) -> __m128i {
15844 unsafe {
15845 static_assert_round_mode!(IMM8);
15846 let a = a.as_f32x8();
15847 let src = src.as_i16x8();
15848 let r = vcvtps2ph256(a, IMM8, src, k);
15849 transmute(r)
15850 }
15851}
15852
15853#[inline]
15863#[target_feature(enable = "avx512f,avx512vl")]
15864#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15865#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15866#[rustc_legacy_const_generics(2)]
15867pub fn _mm256_maskz_cvtps_ph<const IMM8: i32>(k: __mmask8, a: __m256) -> __m128i {
15868 unsafe {
15869 static_assert_round_mode!(IMM8);
15870 let a = a.as_f32x8();
15871 let r = vcvtps2ph256(a, IMM8, i16x8::ZERO, k);
15872 transmute(r)
15873 }
15874}
15875
15876#[inline]
15886#[target_feature(enable = "avx512f,avx512vl")]
15887#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15888#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15889#[rustc_legacy_const_generics(3)]
15890pub fn _mm_mask_cvtps_ph<const IMM8: i32>(src: __m128i, k: __mmask8, a: __m128) -> __m128i {
15891 unsafe {
15892 static_assert_round_mode!(IMM8);
15893 let a = a.as_f32x4();
15894 let src = src.as_i16x8();
15895 let r = vcvtps2ph128(a, IMM8, src, k);
15896 transmute(r)
15897 }
15898}
15899
15900#[inline]
15910#[target_feature(enable = "avx512f,avx512vl")]
15911#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15912#[cfg_attr(test, assert_instr(vcvtps2ph, IMM8 = 0))]
15913#[rustc_legacy_const_generics(2)]
15914pub fn _mm_maskz_cvtps_ph<const IMM8: i32>(k: __mmask8, a: __m128) -> __m128i {
15915 unsafe {
15916 static_assert_round_mode!(IMM8);
15917 let a = a.as_f32x4();
15918 let r = vcvtps2ph128(a, IMM8, i16x8::ZERO, k);
15919 transmute(r)
15920 }
15921}
15922
15923#[inline]
15928#[target_feature(enable = "avx512f")]
15929#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15930#[cfg_attr(test, assert_instr(vcvtph2ps, SAE = 8))]
15931#[rustc_legacy_const_generics(1)]
15932pub fn _mm512_cvt_roundph_ps<const SAE: i32>(a: __m256i) -> __m512 {
15933 unsafe {
15934 static_assert_sae!(SAE);
15935 let a = a.as_i16x16();
15936 let r = vcvtph2ps(a, f32x16::ZERO, 0b11111111_11111111, SAE);
15937 transmute(r)
15938 }
15939}
15940
15941#[inline]
15946#[target_feature(enable = "avx512f")]
15947#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15948#[cfg_attr(test, assert_instr(vcvtph2ps, SAE = 8))]
15949#[rustc_legacy_const_generics(3)]
15950pub fn _mm512_mask_cvt_roundph_ps<const SAE: i32>(src: __m512, k: __mmask16, a: __m256i) -> __m512 {
15951 unsafe {
15952 static_assert_sae!(SAE);
15953 let a = a.as_i16x16();
15954 let src = src.as_f32x16();
15955 let r = vcvtph2ps(a, src, k, SAE);
15956 transmute(r)
15957 }
15958}
15959
15960#[inline]
15965#[target_feature(enable = "avx512f")]
15966#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15967#[cfg_attr(test, assert_instr(vcvtph2ps, SAE = 8))]
15968#[rustc_legacy_const_generics(2)]
15969pub fn _mm512_maskz_cvt_roundph_ps<const SAE: i32>(k: __mmask16, a: __m256i) -> __m512 {
15970 unsafe {
15971 static_assert_sae!(SAE);
15972 let a = a.as_i16x16();
15973 let r = vcvtph2ps(a, f32x16::ZERO, k, SAE);
15974 transmute(r)
15975 }
15976}
15977
15978#[inline]
15982#[target_feature(enable = "avx512f")]
15983#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
15984#[cfg_attr(test, assert_instr(vcvtph2ps))]
15985pub fn _mm512_cvtph_ps(a: __m256i) -> __m512 {
15986 unsafe {
15987 transmute(vcvtph2ps(
15988 a.as_i16x16(),
15989 f32x16::ZERO,
15990 0b11111111_11111111,
15991 _MM_FROUND_NO_EXC,
15992 ))
15993 }
15994}
15995
15996#[inline]
16000#[target_feature(enable = "avx512f")]
16001#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16002#[cfg_attr(test, assert_instr(vcvtph2ps))]
16003pub fn _mm512_mask_cvtph_ps(src: __m512, k: __mmask16, a: __m256i) -> __m512 {
16004 unsafe {
16005 transmute(vcvtph2ps(
16006 a.as_i16x16(),
16007 src.as_f32x16(),
16008 k,
16009 _MM_FROUND_NO_EXC,
16010 ))
16011 }
16012}
16013
16014#[inline]
16018#[target_feature(enable = "avx512f")]
16019#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16020#[cfg_attr(test, assert_instr(vcvtph2ps))]
16021pub fn _mm512_maskz_cvtph_ps(k: __mmask16, a: __m256i) -> __m512 {
16022 unsafe { transmute(vcvtph2ps(a.as_i16x16(), f32x16::ZERO, k, _MM_FROUND_NO_EXC)) }
16023}
16024
16025#[inline]
16029#[target_feature(enable = "avx512f,avx512vl")]
16030#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16031#[cfg_attr(test, assert_instr(vcvtph2ps))]
16032pub fn _mm256_mask_cvtph_ps(src: __m256, k: __mmask8, a: __m128i) -> __m256 {
16033 unsafe {
16034 let convert = _mm256_cvtph_ps(a);
16035 transmute(simd_select_bitmask(k, convert.as_f32x8(), src.as_f32x8()))
16036 }
16037}
16038
16039#[inline]
16043#[target_feature(enable = "avx512f,avx512vl")]
16044#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16045#[cfg_attr(test, assert_instr(vcvtph2ps))]
16046pub fn _mm256_maskz_cvtph_ps(k: __mmask8, a: __m128i) -> __m256 {
16047 unsafe {
16048 let convert = _mm256_cvtph_ps(a);
16049 transmute(simd_select_bitmask(k, convert.as_f32x8(), f32x8::ZERO))
16050 }
16051}
16052
16053#[inline]
16057#[target_feature(enable = "avx512f,avx512vl")]
16058#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16059#[cfg_attr(test, assert_instr(vcvtph2ps))]
16060pub fn _mm_mask_cvtph_ps(src: __m128, k: __mmask8, a: __m128i) -> __m128 {
16061 unsafe {
16062 let convert = _mm_cvtph_ps(a);
16063 transmute(simd_select_bitmask(k, convert.as_f32x4(), src.as_f32x4()))
16064 }
16065}
16066
16067#[inline]
16071#[target_feature(enable = "avx512f,avx512vl")]
16072#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16073#[cfg_attr(test, assert_instr(vcvtph2ps))]
16074pub fn _mm_maskz_cvtph_ps(k: __mmask8, a: __m128i) -> __m128 {
16075 unsafe {
16076 let convert = _mm_cvtph_ps(a);
16077 transmute(simd_select_bitmask(k, convert.as_f32x4(), f32x4::ZERO))
16078 }
16079}
16080
16081#[inline]
16086#[target_feature(enable = "avx512f")]
16087#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16088#[cfg_attr(test, assert_instr(vcvttps2dq, SAE = 8))]
16089#[rustc_legacy_const_generics(1)]
16090pub fn _mm512_cvtt_roundps_epi32<const SAE: i32>(a: __m512) -> __m512i {
16091 unsafe {
16092 static_assert_sae!(SAE);
16093 let a = a.as_f32x16();
16094 let r = vcvttps2dq(a, i32x16::ZERO, 0b11111111_11111111, SAE);
16095 transmute(r)
16096 }
16097}
16098
16099#[inline]
16104#[target_feature(enable = "avx512f")]
16105#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16106#[cfg_attr(test, assert_instr(vcvttps2dq, SAE = 8))]
16107#[rustc_legacy_const_generics(3)]
16108pub fn _mm512_mask_cvtt_roundps_epi32<const SAE: i32>(
16109 src: __m512i,
16110 k: __mmask16,
16111 a: __m512,
16112) -> __m512i {
16113 unsafe {
16114 static_assert_sae!(SAE);
16115 let a = a.as_f32x16();
16116 let src = src.as_i32x16();
16117 let r = vcvttps2dq(a, src, k, SAE);
16118 transmute(r)
16119 }
16120}
16121
16122#[inline]
16127#[target_feature(enable = "avx512f")]
16128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16129#[cfg_attr(test, assert_instr(vcvttps2dq, SAE = 8))]
16130#[rustc_legacy_const_generics(2)]
16131pub fn _mm512_maskz_cvtt_roundps_epi32<const SAE: i32>(k: __mmask16, a: __m512) -> __m512i {
16132 unsafe {
16133 static_assert_sae!(SAE);
16134 let a = a.as_f32x16();
16135 let r = vcvttps2dq(a, i32x16::ZERO, k, SAE);
16136 transmute(r)
16137 }
16138}
16139
16140#[inline]
16145#[target_feature(enable = "avx512f")]
16146#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16147#[cfg_attr(test, assert_instr(vcvttps2udq, SAE = 8))]
16148#[rustc_legacy_const_generics(1)]
16149pub fn _mm512_cvtt_roundps_epu32<const SAE: i32>(a: __m512) -> __m512i {
16150 unsafe {
16151 static_assert_sae!(SAE);
16152 let a = a.as_f32x16();
16153 let r = vcvttps2udq(a, u32x16::ZERO, 0b11111111_11111111, SAE);
16154 transmute(r)
16155 }
16156}
16157
16158#[inline]
16163#[target_feature(enable = "avx512f")]
16164#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16165#[cfg_attr(test, assert_instr(vcvttps2udq, SAE = 8))]
16166#[rustc_legacy_const_generics(3)]
16167pub fn _mm512_mask_cvtt_roundps_epu32<const SAE: i32>(
16168 src: __m512i,
16169 k: __mmask16,
16170 a: __m512,
16171) -> __m512i {
16172 unsafe {
16173 static_assert_sae!(SAE);
16174 let a = a.as_f32x16();
16175 let src = src.as_u32x16();
16176 let r = vcvttps2udq(a, src, k, SAE);
16177 transmute(r)
16178 }
16179}
16180
16181#[inline]
16186#[target_feature(enable = "avx512f")]
16187#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16188#[cfg_attr(test, assert_instr(vcvttps2udq, SAE = 8))]
16189#[rustc_legacy_const_generics(2)]
16190pub fn _mm512_maskz_cvtt_roundps_epu32<const SAE: i32>(k: __mmask16, a: __m512) -> __m512i {
16191 unsafe {
16192 static_assert_sae!(SAE);
16193 let a = a.as_f32x16();
16194 let r = vcvttps2udq(a, u32x16::ZERO, k, SAE);
16195 transmute(r)
16196 }
16197}
16198
16199#[inline]
16204#[target_feature(enable = "avx512f")]
16205#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16206#[cfg_attr(test, assert_instr(vcvttpd2dq, SAE = 8))]
16207#[rustc_legacy_const_generics(1)]
16208pub fn _mm512_cvtt_roundpd_epi32<const SAE: i32>(a: __m512d) -> __m256i {
16209 unsafe {
16210 static_assert_sae!(SAE);
16211 let a = a.as_f64x8();
16212 let r = vcvttpd2dq(a, i32x8::ZERO, 0b11111111, SAE);
16213 transmute(r)
16214 }
16215}
16216
16217#[inline]
16222#[target_feature(enable = "avx512f")]
16223#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16224#[cfg_attr(test, assert_instr(vcvttpd2dq, SAE = 8))]
16225#[rustc_legacy_const_generics(3)]
16226pub fn _mm512_mask_cvtt_roundpd_epi32<const SAE: i32>(
16227 src: __m256i,
16228 k: __mmask8,
16229 a: __m512d,
16230) -> __m256i {
16231 unsafe {
16232 static_assert_sae!(SAE);
16233 let a = a.as_f64x8();
16234 let src = src.as_i32x8();
16235 let r = vcvttpd2dq(a, src, k, SAE);
16236 transmute(r)
16237 }
16238}
16239
16240#[inline]
16245#[target_feature(enable = "avx512f")]
16246#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16247#[cfg_attr(test, assert_instr(vcvttpd2dq, SAE = 8))]
16248#[rustc_legacy_const_generics(2)]
16249pub fn _mm512_maskz_cvtt_roundpd_epi32<const SAE: i32>(k: __mmask8, a: __m512d) -> __m256i {
16250 unsafe {
16251 static_assert_sae!(SAE);
16252 let a = a.as_f64x8();
16253 let r = vcvttpd2dq(a, i32x8::ZERO, k, SAE);
16254 transmute(r)
16255 }
16256}
16257
16258#[inline]
16263#[target_feature(enable = "avx512f")]
16264#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16265#[cfg_attr(test, assert_instr(vcvttpd2udq, SAE = 8))]
16266#[rustc_legacy_const_generics(1)]
16267pub fn _mm512_cvtt_roundpd_epu32<const SAE: i32>(a: __m512d) -> __m256i {
16268 unsafe {
16269 static_assert_sae!(SAE);
16270 let a = a.as_f64x8();
16271 let r = vcvttpd2udq(a, i32x8::ZERO, 0b11111111, SAE);
16272 transmute(r)
16273 }
16274}
16275
16276#[inline]
16281#[target_feature(enable = "avx512f")]
16282#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16283#[cfg_attr(test, assert_instr(vcvttpd2udq, SAE = 8))]
16284#[rustc_legacy_const_generics(3)]
16285pub fn _mm512_mask_cvtt_roundpd_epu32<const SAE: i32>(
16286 src: __m256i,
16287 k: __mmask8,
16288 a: __m512d,
16289) -> __m256i {
16290 unsafe {
16291 static_assert_sae!(SAE);
16292 let a = a.as_f64x8();
16293 let src = src.as_i32x8();
16294 let r = vcvttpd2udq(a, src, k, SAE);
16295 transmute(r)
16296 }
16297}
16298
16299#[inline]
16303#[target_feature(enable = "avx512f")]
16304#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16305#[cfg_attr(test, assert_instr(vcvttps2dq))]
16306pub fn _mm512_cvttps_epi32(a: __m512) -> __m512i {
16307 unsafe {
16308 transmute(vcvttps2dq(
16309 a.as_f32x16(),
16310 i32x16::ZERO,
16311 0b11111111_11111111,
16312 _MM_FROUND_CUR_DIRECTION,
16313 ))
16314 }
16315}
16316
16317#[inline]
16321#[target_feature(enable = "avx512f")]
16322#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16323#[cfg_attr(test, assert_instr(vcvttps2dq))]
16324pub fn _mm512_mask_cvttps_epi32(src: __m512i, k: __mmask16, a: __m512) -> __m512i {
16325 unsafe {
16326 transmute(vcvttps2dq(
16327 a.as_f32x16(),
16328 src.as_i32x16(),
16329 k,
16330 _MM_FROUND_CUR_DIRECTION,
16331 ))
16332 }
16333}
16334
16335#[inline]
16339#[target_feature(enable = "avx512f")]
16340#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16341#[cfg_attr(test, assert_instr(vcvttps2dq))]
16342pub fn _mm512_maskz_cvttps_epi32(k: __mmask16, a: __m512) -> __m512i {
16343 unsafe {
16344 transmute(vcvttps2dq(
16345 a.as_f32x16(),
16346 i32x16::ZERO,
16347 k,
16348 _MM_FROUND_CUR_DIRECTION,
16349 ))
16350 }
16351}
16352
16353#[inline]
16357#[target_feature(enable = "avx512f,avx512vl")]
16358#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16359#[cfg_attr(test, assert_instr(vcvttps2dq))]
16360pub fn _mm256_mask_cvttps_epi32(src: __m256i, k: __mmask8, a: __m256) -> __m256i {
16361 unsafe { simd_select_bitmask(k, _mm256_cvttps_epi32(a).as_i32x8(), src.as_i32x8()).as_m256i() }
16362}
16363
16364#[inline]
16368#[target_feature(enable = "avx512f,avx512vl")]
16369#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16370#[cfg_attr(test, assert_instr(vcvttps2dq))]
16371pub fn _mm256_maskz_cvttps_epi32(k: __mmask8, a: __m256) -> __m256i {
16372 _mm256_mask_cvttps_epi32(_mm256_setzero_si256(), k, a)
16373}
16374
16375#[inline]
16379#[target_feature(enable = "avx512f,avx512vl")]
16380#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16381#[cfg_attr(test, assert_instr(vcvttps2dq))]
16382pub fn _mm_mask_cvttps_epi32(src: __m128i, k: __mmask8, a: __m128) -> __m128i {
16383 unsafe { simd_select_bitmask(k, _mm_cvttps_epi32(a).as_i32x4(), src.as_i32x4()).as_m128i() }
16384}
16385
16386#[inline]
16390#[target_feature(enable = "avx512f,avx512vl")]
16391#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16392#[cfg_attr(test, assert_instr(vcvttps2dq))]
16393pub fn _mm_maskz_cvttps_epi32(k: __mmask8, a: __m128) -> __m128i {
16394 _mm_mask_cvttps_epi32(_mm_setzero_si128(), k, a)
16395}
16396
16397#[inline]
16401#[target_feature(enable = "avx512f")]
16402#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16403#[cfg_attr(test, assert_instr(vcvttps2udq))]
16404pub fn _mm512_cvttps_epu32(a: __m512) -> __m512i {
16405 unsafe {
16406 transmute(vcvttps2udq(
16407 a.as_f32x16(),
16408 u32x16::ZERO,
16409 0b11111111_11111111,
16410 _MM_FROUND_CUR_DIRECTION,
16411 ))
16412 }
16413}
16414
16415#[inline]
16419#[target_feature(enable = "avx512f")]
16420#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16421#[cfg_attr(test, assert_instr(vcvttps2udq))]
16422pub fn _mm512_mask_cvttps_epu32(src: __m512i, k: __mmask16, a: __m512) -> __m512i {
16423 unsafe {
16424 transmute(vcvttps2udq(
16425 a.as_f32x16(),
16426 src.as_u32x16(),
16427 k,
16428 _MM_FROUND_CUR_DIRECTION,
16429 ))
16430 }
16431}
16432
16433#[inline]
16437#[target_feature(enable = "avx512f")]
16438#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16439#[cfg_attr(test, assert_instr(vcvttps2udq))]
16440pub fn _mm512_maskz_cvttps_epu32(k: __mmask16, a: __m512) -> __m512i {
16441 unsafe {
16442 transmute(vcvttps2udq(
16443 a.as_f32x16(),
16444 u32x16::ZERO,
16445 k,
16446 _MM_FROUND_CUR_DIRECTION,
16447 ))
16448 }
16449}
16450
16451#[inline]
16455#[target_feature(enable = "avx512f,avx512vl")]
16456#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16457#[cfg_attr(test, assert_instr(vcvttps2udq))]
16458pub fn _mm256_cvttps_epu32(a: __m256) -> __m256i {
16459 unsafe { transmute(vcvttps2udq256(a.as_f32x8(), u32x8::ZERO, 0b11111111)) }
16460}
16461
16462#[inline]
16466#[target_feature(enable = "avx512f,avx512vl")]
16467#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16468#[cfg_attr(test, assert_instr(vcvttps2udq))]
16469pub fn _mm256_mask_cvttps_epu32(src: __m256i, k: __mmask8, a: __m256) -> __m256i {
16470 unsafe { transmute(vcvttps2udq256(a.as_f32x8(), src.as_u32x8(), k)) }
16471}
16472
16473#[inline]
16477#[target_feature(enable = "avx512f,avx512vl")]
16478#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16479#[cfg_attr(test, assert_instr(vcvttps2udq))]
16480pub fn _mm256_maskz_cvttps_epu32(k: __mmask8, a: __m256) -> __m256i {
16481 unsafe { transmute(vcvttps2udq256(a.as_f32x8(), u32x8::ZERO, k)) }
16482}
16483
16484#[inline]
16488#[target_feature(enable = "avx512f,avx512vl")]
16489#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16490#[cfg_attr(test, assert_instr(vcvttps2udq))]
16491pub fn _mm_cvttps_epu32(a: __m128) -> __m128i {
16492 unsafe { transmute(vcvttps2udq128(a.as_f32x4(), u32x4::ZERO, 0b11111111)) }
16493}
16494
16495#[inline]
16499#[target_feature(enable = "avx512f,avx512vl")]
16500#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16501#[cfg_attr(test, assert_instr(vcvttps2udq))]
16502pub fn _mm_mask_cvttps_epu32(src: __m128i, k: __mmask8, a: __m128) -> __m128i {
16503 unsafe { transmute(vcvttps2udq128(a.as_f32x4(), src.as_u32x4(), k)) }
16504}
16505
16506#[inline]
16510#[target_feature(enable = "avx512f,avx512vl")]
16511#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16512#[cfg_attr(test, assert_instr(vcvttps2udq))]
16513pub fn _mm_maskz_cvttps_epu32(k: __mmask8, a: __m128) -> __m128i {
16514 unsafe { transmute(vcvttps2udq128(a.as_f32x4(), u32x4::ZERO, k)) }
16515}
16516
16517#[inline]
16522#[target_feature(enable = "avx512f")]
16523#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16524#[cfg_attr(test, assert_instr(vcvttpd2udq, SAE = 8))]
16525#[rustc_legacy_const_generics(2)]
16526pub fn _mm512_maskz_cvtt_roundpd_epu32<const SAE: i32>(k: __mmask8, a: __m512d) -> __m256i {
16527 unsafe {
16528 static_assert_sae!(SAE);
16529 let a = a.as_f64x8();
16530 let r = vcvttpd2udq(a, i32x8::ZERO, k, SAE);
16531 transmute(r)
16532 }
16533}
16534
16535#[inline]
16539#[target_feature(enable = "avx512f")]
16540#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16541#[cfg_attr(test, assert_instr(vcvttpd2dq))]
16542pub fn _mm512_cvttpd_epi32(a: __m512d) -> __m256i {
16543 unsafe {
16544 transmute(vcvttpd2dq(
16545 a.as_f64x8(),
16546 i32x8::ZERO,
16547 0b11111111,
16548 _MM_FROUND_CUR_DIRECTION,
16549 ))
16550 }
16551}
16552
16553#[inline]
16557#[target_feature(enable = "avx512f")]
16558#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16559#[cfg_attr(test, assert_instr(vcvttpd2dq))]
16560pub fn _mm512_mask_cvttpd_epi32(src: __m256i, k: __mmask8, a: __m512d) -> __m256i {
16561 unsafe {
16562 transmute(vcvttpd2dq(
16563 a.as_f64x8(),
16564 src.as_i32x8(),
16565 k,
16566 _MM_FROUND_CUR_DIRECTION,
16567 ))
16568 }
16569}
16570
16571#[inline]
16575#[target_feature(enable = "avx512f")]
16576#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16577#[cfg_attr(test, assert_instr(vcvttpd2dq))]
16578pub fn _mm512_maskz_cvttpd_epi32(k: __mmask8, a: __m512d) -> __m256i {
16579 unsafe {
16580 transmute(vcvttpd2dq(
16581 a.as_f64x8(),
16582 i32x8::ZERO,
16583 k,
16584 _MM_FROUND_CUR_DIRECTION,
16585 ))
16586 }
16587}
16588
16589#[inline]
16593#[target_feature(enable = "avx512f,avx512vl")]
16594#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16595#[cfg_attr(test, assert_instr(vcvttpd2dq))]
16596pub fn _mm256_mask_cvttpd_epi32(src: __m128i, k: __mmask8, a: __m256d) -> __m128i {
16597 unsafe { simd_select_bitmask(k, _mm256_cvttpd_epi32(a).as_i32x4(), src.as_i32x4()).as_m128i() }
16598}
16599
16600#[inline]
16604#[target_feature(enable = "avx512f,avx512vl")]
16605#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16606#[cfg_attr(test, assert_instr(vcvttpd2dq))]
16607pub fn _mm256_maskz_cvttpd_epi32(k: __mmask8, a: __m256d) -> __m128i {
16608 _mm256_mask_cvttpd_epi32(_mm_setzero_si128(), k, a)
16609}
16610
16611#[inline]
16615#[target_feature(enable = "avx512f,avx512vl")]
16616#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16617#[cfg_attr(test, assert_instr(vcvttpd2dq))]
16618pub fn _mm_mask_cvttpd_epi32(src: __m128i, k: __mmask8, a: __m128d) -> __m128i {
16619 unsafe { transmute(vcvttpd2dq128(a.as_f64x2(), src.as_i32x4(), k)) }
16620}
16621
16622#[inline]
16626#[target_feature(enable = "avx512f,avx512vl")]
16627#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16628#[cfg_attr(test, assert_instr(vcvttpd2dq))]
16629pub fn _mm_maskz_cvttpd_epi32(k: __mmask8, a: __m128d) -> __m128i {
16630 unsafe { transmute(vcvttpd2dq128(a.as_f64x2(), i32x4::ZERO, k)) }
16631}
16632
16633#[inline]
16637#[target_feature(enable = "avx512f")]
16638#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16639#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16640pub fn _mm512_cvttpd_epu32(a: __m512d) -> __m256i {
16641 unsafe {
16642 transmute(vcvttpd2udq(
16643 a.as_f64x8(),
16644 i32x8::ZERO,
16645 0b11111111,
16646 _MM_FROUND_CUR_DIRECTION,
16647 ))
16648 }
16649}
16650
16651#[inline]
16655#[target_feature(enable = "avx512f")]
16656#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16657#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16658pub fn _mm512_mask_cvttpd_epu32(src: __m256i, k: __mmask8, a: __m512d) -> __m256i {
16659 unsafe {
16660 transmute(vcvttpd2udq(
16661 a.as_f64x8(),
16662 src.as_i32x8(),
16663 k,
16664 _MM_FROUND_CUR_DIRECTION,
16665 ))
16666 }
16667}
16668
16669#[inline]
16673#[target_feature(enable = "avx512f")]
16674#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16675#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16676pub fn _mm512_maskz_cvttpd_epu32(k: __mmask8, a: __m512d) -> __m256i {
16677 unsafe {
16678 transmute(vcvttpd2udq(
16679 a.as_f64x8(),
16680 i32x8::ZERO,
16681 k,
16682 _MM_FROUND_CUR_DIRECTION,
16683 ))
16684 }
16685}
16686
16687#[inline]
16691#[target_feature(enable = "avx512f,avx512vl")]
16692#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16693#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16694pub fn _mm256_cvttpd_epu32(a: __m256d) -> __m128i {
16695 unsafe { transmute(vcvttpd2udq256(a.as_f64x4(), i32x4::ZERO, 0b11111111)) }
16696}
16697
16698#[inline]
16702#[target_feature(enable = "avx512f,avx512vl")]
16703#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16704#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16705pub fn _mm256_mask_cvttpd_epu32(src: __m128i, k: __mmask8, a: __m256d) -> __m128i {
16706 unsafe { transmute(vcvttpd2udq256(a.as_f64x4(), src.as_i32x4(), k)) }
16707}
16708
16709#[inline]
16713#[target_feature(enable = "avx512f,avx512vl")]
16714#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16715#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16716pub fn _mm256_maskz_cvttpd_epu32(k: __mmask8, a: __m256d) -> __m128i {
16717 unsafe { transmute(vcvttpd2udq256(a.as_f64x4(), i32x4::ZERO, k)) }
16718}
16719
16720#[inline]
16724#[target_feature(enable = "avx512f,avx512vl")]
16725#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16726#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16727pub fn _mm_cvttpd_epu32(a: __m128d) -> __m128i {
16728 unsafe { transmute(vcvttpd2udq128(a.as_f64x2(), i32x4::ZERO, 0b11111111)) }
16729}
16730
16731#[inline]
16735#[target_feature(enable = "avx512f,avx512vl")]
16736#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16737#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16738pub fn _mm_mask_cvttpd_epu32(src: __m128i, k: __mmask8, a: __m128d) -> __m128i {
16739 unsafe { transmute(vcvttpd2udq128(a.as_f64x2(), src.as_i32x4(), k)) }
16740}
16741
16742#[inline]
16746#[target_feature(enable = "avx512f,avx512vl")]
16747#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16748#[cfg_attr(test, assert_instr(vcvttpd2udq))]
16749pub fn _mm_maskz_cvttpd_epu32(k: __mmask8, a: __m128d) -> __m128i {
16750 unsafe { transmute(vcvttpd2udq128(a.as_f64x2(), i32x4::ZERO, k)) }
16751}
16752
16753#[inline]
16757#[target_feature(enable = "avx512f")]
16758#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16759#[cfg_attr(test, assert_instr(vxorps))]
16760#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16761pub const fn _mm512_setzero_pd() -> __m512d {
16762 unsafe { const { mem::zeroed() } }
16764}
16765
16766#[inline]
16770#[target_feature(enable = "avx512f")]
16771#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16772#[cfg_attr(test, assert_instr(vxorps))]
16773#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16774pub const fn _mm512_setzero_ps() -> __m512 {
16775 unsafe { const { mem::zeroed() } }
16777}
16778
16779#[inline]
16783#[target_feature(enable = "avx512f")]
16784#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16785#[cfg_attr(test, assert_instr(vxorps))]
16786#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16787pub const fn _mm512_setzero() -> __m512 {
16788 unsafe { const { mem::zeroed() } }
16790}
16791
16792#[inline]
16796#[target_feature(enable = "avx512f")]
16797#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16798#[cfg_attr(test, assert_instr(vxorps))]
16799#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16800pub const fn _mm512_setzero_si512() -> __m512i {
16801 unsafe { const { mem::zeroed() } }
16803}
16804
16805#[inline]
16809#[target_feature(enable = "avx512f")]
16810#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16811#[cfg_attr(test, assert_instr(vxorps))]
16812#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16813pub const fn _mm512_setzero_epi32() -> __m512i {
16814 unsafe { const { mem::zeroed() } }
16816}
16817
16818#[inline]
16823#[target_feature(enable = "avx512f")]
16824#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16825#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16826pub const fn _mm512_setr_epi32(
16827 e15: i32,
16828 e14: i32,
16829 e13: i32,
16830 e12: i32,
16831 e11: i32,
16832 e10: i32,
16833 e9: i32,
16834 e8: i32,
16835 e7: i32,
16836 e6: i32,
16837 e5: i32,
16838 e4: i32,
16839 e3: i32,
16840 e2: i32,
16841 e1: i32,
16842 e0: i32,
16843) -> __m512i {
16844 unsafe {
16845 let r = i32x16::new(
16846 e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0,
16847 );
16848 transmute(r)
16849 }
16850}
16851
16852#[inline]
16856#[target_feature(enable = "avx512f")]
16857#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16858#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16859pub const fn _mm512_set_epi8(
16860 e63: i8,
16861 e62: i8,
16862 e61: i8,
16863 e60: i8,
16864 e59: i8,
16865 e58: i8,
16866 e57: i8,
16867 e56: i8,
16868 e55: i8,
16869 e54: i8,
16870 e53: i8,
16871 e52: i8,
16872 e51: i8,
16873 e50: i8,
16874 e49: i8,
16875 e48: i8,
16876 e47: i8,
16877 e46: i8,
16878 e45: i8,
16879 e44: i8,
16880 e43: i8,
16881 e42: i8,
16882 e41: i8,
16883 e40: i8,
16884 e39: i8,
16885 e38: i8,
16886 e37: i8,
16887 e36: i8,
16888 e35: i8,
16889 e34: i8,
16890 e33: i8,
16891 e32: i8,
16892 e31: i8,
16893 e30: i8,
16894 e29: i8,
16895 e28: i8,
16896 e27: i8,
16897 e26: i8,
16898 e25: i8,
16899 e24: i8,
16900 e23: i8,
16901 e22: i8,
16902 e21: i8,
16903 e20: i8,
16904 e19: i8,
16905 e18: i8,
16906 e17: i8,
16907 e16: i8,
16908 e15: i8,
16909 e14: i8,
16910 e13: i8,
16911 e12: i8,
16912 e11: i8,
16913 e10: i8,
16914 e9: i8,
16915 e8: i8,
16916 e7: i8,
16917 e6: i8,
16918 e5: i8,
16919 e4: i8,
16920 e3: i8,
16921 e2: i8,
16922 e1: i8,
16923 e0: i8,
16924) -> __m512i {
16925 unsafe {
16926 let r = i8x64::from_array([
16927 e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18,
16928 e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35,
16929 e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52,
16930 e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63,
16931 ]);
16932 transmute(r)
16933 }
16934}
16935
16936#[inline]
16940#[target_feature(enable = "avx512f")]
16941#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16942#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16943pub const fn _mm512_set_epi16(
16944 e31: i16,
16945 e30: i16,
16946 e29: i16,
16947 e28: i16,
16948 e27: i16,
16949 e26: i16,
16950 e25: i16,
16951 e24: i16,
16952 e23: i16,
16953 e22: i16,
16954 e21: i16,
16955 e20: i16,
16956 e19: i16,
16957 e18: i16,
16958 e17: i16,
16959 e16: i16,
16960 e15: i16,
16961 e14: i16,
16962 e13: i16,
16963 e12: i16,
16964 e11: i16,
16965 e10: i16,
16966 e9: i16,
16967 e8: i16,
16968 e7: i16,
16969 e6: i16,
16970 e5: i16,
16971 e4: i16,
16972 e3: i16,
16973 e2: i16,
16974 e1: i16,
16975 e0: i16,
16976) -> __m512i {
16977 unsafe {
16978 let r = i16x32::new(
16979 e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18,
16980 e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31,
16981 );
16982 transmute(r)
16983 }
16984}
16985
16986#[inline]
16990#[target_feature(enable = "avx512f")]
16991#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
16992#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
16993pub const fn _mm512_set4_epi32(d: i32, c: i32, b: i32, a: i32) -> __m512i {
16994 _mm512_set_epi32(d, c, b, a, d, c, b, a, d, c, b, a, d, c, b, a)
16995}
16996
16997#[inline]
17001#[target_feature(enable = "avx512f")]
17002#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17003#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
17004pub const fn _mm512_set4_ps(d: f32, c: f32, b: f32, a: f32) -> __m512 {
17005 _mm512_set_ps(d, c, b, a, d, c, b, a, d, c, b, a, d, c, b, a)
17006}
17007
17008#[inline]
17012#[target_feature(enable = "avx512f")]
17013#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17014#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
17015pub const fn _mm512_set4_pd(d: f64, c: f64, b: f64, a: f64) -> __m512d {
17016 _mm512_set_pd(d, c, b, a, d, c, b, a)
17017}
17018
17019#[inline]
17023#[target_feature(enable = "avx512f")]
17024#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17025#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
17026pub const fn _mm512_setr4_epi32(d: i32, c: i32, b: i32, a: i32) -> __m512i {
17027 _mm512_set_epi32(a, b, c, d, a, b, c, d, a, b, c, d, a, b, c, d)
17028}
17029
17030#[inline]
17034#[target_feature(enable = "avx512f")]
17035#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17036#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
17037pub const fn _mm512_setr4_ps(d: f32, c: f32, b: f32, a: f32) -> __m512 {
17038 _mm512_set_ps(a, b, c, d, a, b, c, d, a, b, c, d, a, b, c, d)
17039}
17040
17041#[inline]
17045#[target_feature(enable = "avx512f")]
17046#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17047#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
17048pub const fn _mm512_setr4_pd(d: f64, c: f64, b: f64, a: f64) -> __m512d {
17049 _mm512_set_pd(a, b, c, d, a, b, c, d)
17050}
17051
17052#[inline]
17056#[target_feature(enable = "avx512f")]
17057#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17058#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
17059pub const fn _mm512_set_epi64(
17060 e0: i64,
17061 e1: i64,
17062 e2: i64,
17063 e3: i64,
17064 e4: i64,
17065 e5: i64,
17066 e6: i64,
17067 e7: i64,
17068) -> __m512i {
17069 _mm512_setr_epi64(e7, e6, e5, e4, e3, e2, e1, e0)
17070}
17071
17072#[inline]
17076#[target_feature(enable = "avx512f")]
17077#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17078#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
17079pub const fn _mm512_setr_epi64(
17080 e0: i64,
17081 e1: i64,
17082 e2: i64,
17083 e3: i64,
17084 e4: i64,
17085 e5: i64,
17086 e6: i64,
17087 e7: i64,
17088) -> __m512i {
17089 unsafe {
17090 let r = i64x8::new(e0, e1, e2, e3, e4, e5, e6, e7);
17091 transmute(r)
17092 }
17093}
17094
17095#[inline]
17099#[target_feature(enable = "avx512f")]
17100#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17101#[cfg_attr(test, assert_instr(vgatherdpd, SCALE = 1))]
17102#[rustc_legacy_const_generics(2)]
17103pub unsafe fn _mm512_i32gather_pd<const SCALE: i32>(
17104 offsets: __m256i,
17105 slice: *const f64,
17106) -> __m512d {
17107 static_assert_imm8_scale!(SCALE);
17108 let zero = f64x8::ZERO;
17109 let neg_one = -1;
17110 let slice = slice as *const i8;
17111 let offsets = offsets.as_i32x8();
17112 let r = vgatherdpd(zero, slice, offsets, neg_one, SCALE);
17113 transmute(r)
17114}
17115
17116#[inline]
17120#[target_feature(enable = "avx512f")]
17121#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17122#[cfg_attr(test, assert_instr(vgatherdpd, SCALE = 1))]
17123#[rustc_legacy_const_generics(4)]
17124pub unsafe fn _mm512_mask_i32gather_pd<const SCALE: i32>(
17125 src: __m512d,
17126 mask: __mmask8,
17127 offsets: __m256i,
17128 slice: *const f64,
17129) -> __m512d {
17130 static_assert_imm8_scale!(SCALE);
17131 let src = src.as_f64x8();
17132 let slice = slice as *const i8;
17133 let offsets = offsets.as_i32x8();
17134 let r = vgatherdpd(src, slice, offsets, mask as i8, SCALE);
17135 transmute(r)
17136}
17137
17138#[inline]
17142#[target_feature(enable = "avx512f")]
17143#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17144#[cfg_attr(test, assert_instr(vgatherqpd, SCALE = 1))]
17145#[rustc_legacy_const_generics(2)]
17146pub unsafe fn _mm512_i64gather_pd<const SCALE: i32>(
17147 offsets: __m512i,
17148 slice: *const f64,
17149) -> __m512d {
17150 static_assert_imm8_scale!(SCALE);
17151 let zero = f64x8::ZERO;
17152 let neg_one = -1;
17153 let slice = slice as *const i8;
17154 let offsets = offsets.as_i64x8();
17155 let r = vgatherqpd(zero, slice, offsets, neg_one, SCALE);
17156 transmute(r)
17157}
17158
17159#[inline]
17163#[target_feature(enable = "avx512f")]
17164#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17165#[cfg_attr(test, assert_instr(vgatherqpd, SCALE = 1))]
17166#[rustc_legacy_const_generics(4)]
17167pub unsafe fn _mm512_mask_i64gather_pd<const SCALE: i32>(
17168 src: __m512d,
17169 mask: __mmask8,
17170 offsets: __m512i,
17171 slice: *const f64,
17172) -> __m512d {
17173 static_assert_imm8_scale!(SCALE);
17174 let src = src.as_f64x8();
17175 let slice = slice as *const i8;
17176 let offsets = offsets.as_i64x8();
17177 let r = vgatherqpd(src, slice, offsets, mask as i8, SCALE);
17178 transmute(r)
17179}
17180
17181#[inline]
17185#[target_feature(enable = "avx512f")]
17186#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17187#[cfg_attr(test, assert_instr(vgatherqps, SCALE = 1))]
17188#[rustc_legacy_const_generics(2)]
17189pub unsafe fn _mm512_i64gather_ps<const SCALE: i32>(offsets: __m512i, slice: *const f32) -> __m256 {
17190 static_assert_imm8_scale!(SCALE);
17191 let zero = f32x8::ZERO;
17192 let neg_one = -1;
17193 let slice = slice as *const i8;
17194 let offsets = offsets.as_i64x8();
17195 let r = vgatherqps(zero, slice, offsets, neg_one, SCALE);
17196 transmute(r)
17197}
17198
17199#[inline]
17203#[target_feature(enable = "avx512f")]
17204#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17205#[cfg_attr(test, assert_instr(vgatherqps, SCALE = 1))]
17206#[rustc_legacy_const_generics(4)]
17207pub unsafe fn _mm512_mask_i64gather_ps<const SCALE: i32>(
17208 src: __m256,
17209 mask: __mmask8,
17210 offsets: __m512i,
17211 slice: *const f32,
17212) -> __m256 {
17213 static_assert_imm8_scale!(SCALE);
17214 let src = src.as_f32x8();
17215 let slice = slice as *const i8;
17216 let offsets = offsets.as_i64x8();
17217 let r = vgatherqps(src, slice, offsets, mask as i8, SCALE);
17218 transmute(r)
17219}
17220
17221#[inline]
17225#[target_feature(enable = "avx512f")]
17226#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17227#[cfg_attr(test, assert_instr(vgatherdps, SCALE = 1))]
17228#[rustc_legacy_const_generics(2)]
17229pub unsafe fn _mm512_i32gather_ps<const SCALE: i32>(offsets: __m512i, slice: *const f32) -> __m512 {
17230 static_assert_imm8_scale!(SCALE);
17231 let zero = f32x16::ZERO;
17232 let neg_one = -1;
17233 let slice = slice as *const i8;
17234 let offsets = offsets.as_i32x16();
17235 let r = vgatherdps(zero, slice, offsets, neg_one, SCALE);
17236 transmute(r)
17237}
17238
17239#[inline]
17243#[target_feature(enable = "avx512f")]
17244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17245#[cfg_attr(test, assert_instr(vgatherdps, SCALE = 1))]
17246#[rustc_legacy_const_generics(4)]
17247pub unsafe fn _mm512_mask_i32gather_ps<const SCALE: i32>(
17248 src: __m512,
17249 mask: __mmask16,
17250 offsets: __m512i,
17251 slice: *const f32,
17252) -> __m512 {
17253 static_assert_imm8_scale!(SCALE);
17254 let src = src.as_f32x16();
17255 let slice = slice as *const i8;
17256 let offsets = offsets.as_i32x16();
17257 let r = vgatherdps(src, slice, offsets, mask as i16, SCALE);
17258 transmute(r)
17259}
17260
17261#[inline]
17265#[target_feature(enable = "avx512f")]
17266#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17267#[cfg_attr(test, assert_instr(vpgatherdd, SCALE = 1))]
17268#[rustc_legacy_const_generics(2)]
17269pub unsafe fn _mm512_i32gather_epi32<const SCALE: i32>(
17270 offsets: __m512i,
17271 slice: *const i32,
17272) -> __m512i {
17273 static_assert_imm8_scale!(SCALE);
17274 let zero = i32x16::ZERO;
17275 let neg_one = -1;
17276 let slice = slice as *const i8;
17277 let offsets = offsets.as_i32x16();
17278 let r = vpgatherdd(zero, slice, offsets, neg_one, SCALE);
17279 transmute(r)
17280}
17281
17282#[inline]
17286#[target_feature(enable = "avx512f")]
17287#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17288#[cfg_attr(test, assert_instr(vpgatherdd, SCALE = 1))]
17289#[rustc_legacy_const_generics(4)]
17290pub unsafe fn _mm512_mask_i32gather_epi32<const SCALE: i32>(
17291 src: __m512i,
17292 mask: __mmask16,
17293 offsets: __m512i,
17294 slice: *const i32,
17295) -> __m512i {
17296 static_assert_imm8_scale!(SCALE);
17297 let src = src.as_i32x16();
17298 let mask = mask as i16;
17299 let slice = slice as *const i8;
17300 let offsets = offsets.as_i32x16();
17301 let r = vpgatherdd(src, slice, offsets, mask, SCALE);
17302 transmute(r)
17303}
17304
17305#[inline]
17309#[target_feature(enable = "avx512f")]
17310#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17311#[cfg_attr(test, assert_instr(vpgatherdq, SCALE = 1))]
17312#[rustc_legacy_const_generics(2)]
17313pub unsafe fn _mm512_i32gather_epi64<const SCALE: i32>(
17314 offsets: __m256i,
17315 slice: *const i64,
17316) -> __m512i {
17317 static_assert_imm8_scale!(SCALE);
17318 let zero = i64x8::ZERO;
17319 let neg_one = -1;
17320 let slice = slice as *const i8;
17321 let offsets = offsets.as_i32x8();
17322 let r = vpgatherdq(zero, slice, offsets, neg_one, SCALE);
17323 transmute(r)
17324}
17325
17326#[inline]
17330#[target_feature(enable = "avx512f")]
17331#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17332#[cfg_attr(test, assert_instr(vpgatherdq, SCALE = 1))]
17333#[rustc_legacy_const_generics(4)]
17334pub unsafe fn _mm512_mask_i32gather_epi64<const SCALE: i32>(
17335 src: __m512i,
17336 mask: __mmask8,
17337 offsets: __m256i,
17338 slice: *const i64,
17339) -> __m512i {
17340 static_assert_imm8_scale!(SCALE);
17341 let src = src.as_i64x8();
17342 let mask = mask as i8;
17343 let slice = slice as *const i8;
17344 let offsets = offsets.as_i32x8();
17345 let r = vpgatherdq(src, slice, offsets, mask, SCALE);
17346 transmute(r)
17347}
17348
17349#[inline]
17353#[target_feature(enable = "avx512f")]
17354#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17355#[cfg_attr(test, assert_instr(vpgatherqq, SCALE = 1))]
17356#[rustc_legacy_const_generics(2)]
17357pub unsafe fn _mm512_i64gather_epi64<const SCALE: i32>(
17358 offsets: __m512i,
17359 slice: *const i64,
17360) -> __m512i {
17361 static_assert_imm8_scale!(SCALE);
17362 let zero = i64x8::ZERO;
17363 let neg_one = -1;
17364 let slice = slice as *const i8;
17365 let offsets = offsets.as_i64x8();
17366 let r = vpgatherqq(zero, slice, offsets, neg_one, SCALE);
17367 transmute(r)
17368}
17369
17370#[inline]
17374#[target_feature(enable = "avx512f")]
17375#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17376#[cfg_attr(test, assert_instr(vpgatherqq, SCALE = 1))]
17377#[rustc_legacy_const_generics(4)]
17378pub unsafe fn _mm512_mask_i64gather_epi64<const SCALE: i32>(
17379 src: __m512i,
17380 mask: __mmask8,
17381 offsets: __m512i,
17382 slice: *const i64,
17383) -> __m512i {
17384 static_assert_imm8_scale!(SCALE);
17385 let src = src.as_i64x8();
17386 let mask = mask as i8;
17387 let slice = slice as *const i8;
17388 let offsets = offsets.as_i64x8();
17389 let r = vpgatherqq(src, slice, offsets, mask, SCALE);
17390 transmute(r)
17391}
17392
17393#[inline]
17397#[target_feature(enable = "avx512f")]
17398#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17399#[cfg_attr(test, assert_instr(vpgatherqd, SCALE = 1))]
17400#[rustc_legacy_const_generics(2)]
17401pub unsafe fn _mm512_i64gather_epi32<const SCALE: i32>(
17402 offsets: __m512i,
17403 slice: *const i32,
17404) -> __m256i {
17405 static_assert_imm8_scale!(SCALE);
17406 let zeros = i32x8::ZERO;
17407 let neg_one = -1;
17408 let slice = slice as *const i8;
17409 let offsets = offsets.as_i64x8();
17410 let r = vpgatherqd(zeros, slice, offsets, neg_one, SCALE);
17411 transmute(r)
17412}
17413
17414#[inline]
17418#[target_feature(enable = "avx512f")]
17419#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17420#[cfg_attr(test, assert_instr(vpgatherqd, SCALE = 1))]
17421#[rustc_legacy_const_generics(4)]
17422pub unsafe fn _mm512_mask_i64gather_epi32<const SCALE: i32>(
17423 src: __m256i,
17424 mask: __mmask8,
17425 offsets: __m512i,
17426 slice: *const i32,
17427) -> __m256i {
17428 static_assert_imm8_scale!(SCALE);
17429 let src = src.as_i32x8();
17430 let mask = mask as i8;
17431 let slice = slice as *const i8;
17432 let offsets = offsets.as_i64x8();
17433 let r = vpgatherqd(src, slice, offsets, mask, SCALE);
17434 transmute(r)
17435}
17436
17437#[inline]
17441#[target_feature(enable = "avx512f")]
17442#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17443#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
17444#[rustc_legacy_const_generics(3)]
17445pub unsafe fn _mm512_i32scatter_pd<const SCALE: i32>(
17446 slice: *mut f64,
17447 offsets: __m256i,
17448 src: __m512d,
17449) {
17450 static_assert_imm8_scale!(SCALE);
17451 let src = src.as_f64x8();
17452 let neg_one = -1;
17453 let slice = slice as *mut i8;
17454 let offsets = offsets.as_i32x8();
17455 vscatterdpd(slice, neg_one, offsets, src, SCALE);
17456}
17457
17458#[inline]
17462#[target_feature(enable = "avx512f")]
17463#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17464#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
17465#[rustc_legacy_const_generics(4)]
17466pub unsafe fn _mm512_mask_i32scatter_pd<const SCALE: i32>(
17467 slice: *mut f64,
17468 mask: __mmask8,
17469 offsets: __m256i,
17470 src: __m512d,
17471) {
17472 static_assert_imm8_scale!(SCALE);
17473 let src = src.as_f64x8();
17474 let slice = slice as *mut i8;
17475 let offsets = offsets.as_i32x8();
17476 vscatterdpd(slice, mask as i8, offsets, src, SCALE);
17477}
17478
17479#[inline]
17483#[target_feature(enable = "avx512f")]
17484#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17485#[cfg_attr(test, assert_instr(vscatterqpd, SCALE = 1))]
17486#[rustc_legacy_const_generics(3)]
17487pub unsafe fn _mm512_i64scatter_pd<const SCALE: i32>(
17488 slice: *mut f64,
17489 offsets: __m512i,
17490 src: __m512d,
17491) {
17492 static_assert_imm8_scale!(SCALE);
17493 let src = src.as_f64x8();
17494 let neg_one = -1;
17495 let slice = slice as *mut i8;
17496 let offsets = offsets.as_i64x8();
17497 vscatterqpd(slice, neg_one, offsets, src, SCALE);
17498}
17499
17500#[inline]
17504#[target_feature(enable = "avx512f")]
17505#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17506#[cfg_attr(test, assert_instr(vscatterqpd, SCALE = 1))]
17507#[rustc_legacy_const_generics(4)]
17508pub unsafe fn _mm512_mask_i64scatter_pd<const SCALE: i32>(
17509 slice: *mut f64,
17510 mask: __mmask8,
17511 offsets: __m512i,
17512 src: __m512d,
17513) {
17514 static_assert_imm8_scale!(SCALE);
17515 let src = src.as_f64x8();
17516 let slice = slice as *mut i8;
17517 let offsets = offsets.as_i64x8();
17518 vscatterqpd(slice, mask as i8, offsets, src, SCALE);
17519}
17520
17521#[inline]
17525#[target_feature(enable = "avx512f")]
17526#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17527#[cfg_attr(test, assert_instr(vscatterdps, SCALE = 1))]
17528#[rustc_legacy_const_generics(3)]
17529pub unsafe fn _mm512_i32scatter_ps<const SCALE: i32>(
17530 slice: *mut f32,
17531 offsets: __m512i,
17532 src: __m512,
17533) {
17534 static_assert_imm8_scale!(SCALE);
17535 let src = src.as_f32x16();
17536 let neg_one = -1;
17537 let slice = slice as *mut i8;
17538 let offsets = offsets.as_i32x16();
17539 vscatterdps(slice, neg_one, offsets, src, SCALE);
17540}
17541
17542#[inline]
17546#[target_feature(enable = "avx512f")]
17547#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17548#[cfg_attr(test, assert_instr(vscatterdps, SCALE = 1))]
17549#[rustc_legacy_const_generics(4)]
17550pub unsafe fn _mm512_mask_i32scatter_ps<const SCALE: i32>(
17551 slice: *mut f32,
17552 mask: __mmask16,
17553 offsets: __m512i,
17554 src: __m512,
17555) {
17556 static_assert_imm8_scale!(SCALE);
17557 let src = src.as_f32x16();
17558 let slice = slice as *mut i8;
17559 let offsets = offsets.as_i32x16();
17560 vscatterdps(slice, mask as i16, offsets, src, SCALE);
17561}
17562
17563#[inline]
17567#[target_feature(enable = "avx512f")]
17568#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17569#[cfg_attr(test, assert_instr(vscatterqps, SCALE = 1))]
17570#[rustc_legacy_const_generics(3)]
17571pub unsafe fn _mm512_i64scatter_ps<const SCALE: i32>(
17572 slice: *mut f32,
17573 offsets: __m512i,
17574 src: __m256,
17575) {
17576 static_assert_imm8_scale!(SCALE);
17577 let src = src.as_f32x8();
17578 let neg_one = -1;
17579 let slice = slice as *mut i8;
17580 let offsets = offsets.as_i64x8();
17581 vscatterqps(slice, neg_one, offsets, src, SCALE);
17582}
17583
17584#[inline]
17588#[target_feature(enable = "avx512f")]
17589#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17590#[cfg_attr(test, assert_instr(vscatterqps, SCALE = 1))]
17591#[rustc_legacy_const_generics(4)]
17592pub unsafe fn _mm512_mask_i64scatter_ps<const SCALE: i32>(
17593 slice: *mut f32,
17594 mask: __mmask8,
17595 offsets: __m512i,
17596 src: __m256,
17597) {
17598 static_assert_imm8_scale!(SCALE);
17599 let src = src.as_f32x8();
17600 let slice = slice as *mut i8;
17601 let offsets = offsets.as_i64x8();
17602 vscatterqps(slice, mask as i8, offsets, src, SCALE);
17603}
17604
17605#[inline]
17609#[target_feature(enable = "avx512f")]
17610#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17611#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
17612#[rustc_legacy_const_generics(3)]
17613pub unsafe fn _mm512_i32scatter_epi64<const SCALE: i32>(
17614 slice: *mut i64,
17615 offsets: __m256i,
17616 src: __m512i,
17617) {
17618 static_assert_imm8_scale!(SCALE);
17619 let src = src.as_i64x8();
17620 let neg_one = -1;
17621 let slice = slice as *mut i8;
17622 let offsets = offsets.as_i32x8();
17623 vpscatterdq(slice, neg_one, offsets, src, SCALE);
17624}
17625
17626#[inline]
17630#[target_feature(enable = "avx512f")]
17631#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17632#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
17633#[rustc_legacy_const_generics(4)]
17634pub unsafe fn _mm512_mask_i32scatter_epi64<const SCALE: i32>(
17635 slice: *mut i64,
17636 mask: __mmask8,
17637 offsets: __m256i,
17638 src: __m512i,
17639) {
17640 static_assert_imm8_scale!(SCALE);
17641 let src = src.as_i64x8();
17642 let mask = mask as i8;
17643 let slice = slice as *mut i8;
17644 let offsets = offsets.as_i32x8();
17645 vpscatterdq(slice, mask, offsets, src, SCALE);
17646}
17647
17648#[inline]
17652#[target_feature(enable = "avx512f")]
17653#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17654#[cfg_attr(test, assert_instr(vpscatterqq, SCALE = 1))]
17655#[rustc_legacy_const_generics(3)]
17656pub unsafe fn _mm512_i64scatter_epi64<const SCALE: i32>(
17657 slice: *mut i64,
17658 offsets: __m512i,
17659 src: __m512i,
17660) {
17661 static_assert_imm8_scale!(SCALE);
17662 let src = src.as_i64x8();
17663 let neg_one = -1;
17664 let slice = slice as *mut i8;
17665 let offsets = offsets.as_i64x8();
17666 vpscatterqq(slice, neg_one, offsets, src, SCALE);
17667}
17668
17669#[inline]
17673#[target_feature(enable = "avx512f")]
17674#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17675#[cfg_attr(test, assert_instr(vpscatterqq, SCALE = 1))]
17676#[rustc_legacy_const_generics(4)]
17677pub unsafe fn _mm512_mask_i64scatter_epi64<const SCALE: i32>(
17678 slice: *mut i64,
17679 mask: __mmask8,
17680 offsets: __m512i,
17681 src: __m512i,
17682) {
17683 static_assert_imm8_scale!(SCALE);
17684 let src = src.as_i64x8();
17685 let mask = mask as i8;
17686 let slice = slice as *mut i8;
17687 let offsets = offsets.as_i64x8();
17688 vpscatterqq(slice, mask, offsets, src, SCALE);
17689}
17690
17691#[inline]
17695#[target_feature(enable = "avx512f")]
17696#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17697#[cfg_attr(test, assert_instr(vpscatterdd, SCALE = 1))]
17698#[rustc_legacy_const_generics(3)]
17699pub unsafe fn _mm512_i32scatter_epi32<const SCALE: i32>(
17700 slice: *mut i32,
17701 offsets: __m512i,
17702 src: __m512i,
17703) {
17704 static_assert_imm8_scale!(SCALE);
17705 let src = src.as_i32x16();
17706 let neg_one = -1;
17707 let slice = slice as *mut i8;
17708 let offsets = offsets.as_i32x16();
17709 vpscatterdd(slice, neg_one, offsets, src, SCALE);
17710}
17711
17712#[inline]
17716#[target_feature(enable = "avx512f")]
17717#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17718#[cfg_attr(test, assert_instr(vpscatterdd, SCALE = 1))]
17719#[rustc_legacy_const_generics(4)]
17720pub unsafe fn _mm512_mask_i32scatter_epi32<const SCALE: i32>(
17721 slice: *mut i32,
17722 mask: __mmask16,
17723 offsets: __m512i,
17724 src: __m512i,
17725) {
17726 static_assert_imm8_scale!(SCALE);
17727 let src = src.as_i32x16();
17728 let mask = mask as i16;
17729 let slice = slice as *mut i8;
17730 let offsets = offsets.as_i32x16();
17731 vpscatterdd(slice, mask, offsets, src, SCALE);
17732}
17733
17734#[inline]
17738#[target_feature(enable = "avx512f")]
17739#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17740#[cfg_attr(test, assert_instr(vpscatterqd, SCALE = 1))]
17741#[rustc_legacy_const_generics(3)]
17742pub unsafe fn _mm512_i64scatter_epi32<const SCALE: i32>(
17743 slice: *mut i32,
17744 offsets: __m512i,
17745 src: __m256i,
17746) {
17747 static_assert_imm8_scale!(SCALE);
17748 let src = src.as_i32x8();
17749 let neg_one = -1;
17750 let slice = slice as *mut i8;
17751 let offsets = offsets.as_i64x8();
17752 vpscatterqd(slice, neg_one, offsets, src, SCALE);
17753}
17754
17755#[inline]
17759#[target_feature(enable = "avx512f")]
17760#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17761#[cfg_attr(test, assert_instr(vpscatterqd, SCALE = 1))]
17762#[rustc_legacy_const_generics(4)]
17763pub unsafe fn _mm512_mask_i64scatter_epi32<const SCALE: i32>(
17764 slice: *mut i32,
17765 mask: __mmask8,
17766 offsets: __m512i,
17767 src: __m256i,
17768) {
17769 static_assert_imm8_scale!(SCALE);
17770 let src = src.as_i32x8();
17771 let mask = mask as i8;
17772 let slice = slice as *mut i8;
17773 let offsets = offsets.as_i64x8();
17774 vpscatterqd(slice, mask, offsets, src, SCALE);
17775}
17776
17777#[inline]
17782#[target_feature(enable = "avx512f")]
17783#[cfg_attr(test, assert_instr(vpgatherdq, SCALE = 1))]
17784#[rustc_legacy_const_generics(2)]
17785#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17786pub unsafe fn _mm512_i32logather_epi64<const SCALE: i32>(
17787 vindex: __m512i,
17788 base_addr: *const i64,
17789) -> __m512i {
17790 _mm512_i32gather_epi64::<SCALE>(_mm512_castsi512_si256(vindex), base_addr)
17791}
17792
17793#[inline]
17799#[target_feature(enable = "avx512f")]
17800#[cfg_attr(test, assert_instr(vpgatherdq, SCALE = 1))]
17801#[rustc_legacy_const_generics(4)]
17802#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17803pub unsafe fn _mm512_mask_i32logather_epi64<const SCALE: i32>(
17804 src: __m512i,
17805 k: __mmask8,
17806 vindex: __m512i,
17807 base_addr: *const i64,
17808) -> __m512i {
17809 _mm512_mask_i32gather_epi64::<SCALE>(src, k, _mm512_castsi512_si256(vindex), base_addr)
17810}
17811
17812#[inline]
17817#[target_feature(enable = "avx512f")]
17818#[cfg_attr(test, assert_instr(vgatherdpd, SCALE = 1))]
17819#[rustc_legacy_const_generics(2)]
17820#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17821pub unsafe fn _mm512_i32logather_pd<const SCALE: i32>(
17822 vindex: __m512i,
17823 base_addr: *const f64,
17824) -> __m512d {
17825 _mm512_i32gather_pd::<SCALE>(_mm512_castsi512_si256(vindex), base_addr)
17826}
17827
17828#[inline]
17834#[target_feature(enable = "avx512f")]
17835#[cfg_attr(test, assert_instr(vgatherdpd, SCALE = 1))]
17836#[rustc_legacy_const_generics(4)]
17837#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17838pub unsafe fn _mm512_mask_i32logather_pd<const SCALE: i32>(
17839 src: __m512d,
17840 k: __mmask8,
17841 vindex: __m512i,
17842 base_addr: *const f64,
17843) -> __m512d {
17844 _mm512_mask_i32gather_pd::<SCALE>(src, k, _mm512_castsi512_si256(vindex), base_addr)
17845}
17846
17847#[inline]
17852#[target_feature(enable = "avx512f")]
17853#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
17854#[rustc_legacy_const_generics(3)]
17855#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17856pub unsafe fn _mm512_i32loscatter_epi64<const SCALE: i32>(
17857 base_addr: *mut i64,
17858 vindex: __m512i,
17859 a: __m512i,
17860) {
17861 _mm512_i32scatter_epi64::<SCALE>(base_addr, _mm512_castsi512_si256(vindex), a)
17862}
17863
17864#[inline]
17870#[target_feature(enable = "avx512f")]
17871#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
17872#[rustc_legacy_const_generics(4)]
17873#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17874pub unsafe fn _mm512_mask_i32loscatter_epi64<const SCALE: i32>(
17875 base_addr: *mut i64,
17876 k: __mmask8,
17877 vindex: __m512i,
17878 a: __m512i,
17879) {
17880 _mm512_mask_i32scatter_epi64::<SCALE>(base_addr, k, _mm512_castsi512_si256(vindex), a)
17881}
17882
17883#[inline]
17888#[target_feature(enable = "avx512f")]
17889#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
17890#[rustc_legacy_const_generics(3)]
17891#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17892pub unsafe fn _mm512_i32loscatter_pd<const SCALE: i32>(
17893 base_addr: *mut f64,
17894 vindex: __m512i,
17895 a: __m512d,
17896) {
17897 _mm512_i32scatter_pd::<SCALE>(base_addr, _mm512_castsi512_si256(vindex), a)
17898}
17899
17900#[inline]
17906#[target_feature(enable = "avx512f")]
17907#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
17908#[rustc_legacy_const_generics(4)]
17909#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17910pub unsafe fn _mm512_mask_i32loscatter_pd<const SCALE: i32>(
17911 base_addr: *mut f64,
17912 k: __mmask8,
17913 vindex: __m512i,
17914 a: __m512d,
17915) {
17916 _mm512_mask_i32scatter_pd::<SCALE>(base_addr, k, _mm512_castsi512_si256(vindex), a)
17917}
17918
17919#[inline]
17924#[target_feature(enable = "avx512f,avx512vl")]
17925#[cfg_attr(test, assert_instr(vpscatterdd, SCALE = 1))]
17926#[rustc_legacy_const_generics(3)]
17927#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17928pub unsafe fn _mm256_i32scatter_epi32<const SCALE: i32>(
17929 base_addr: *mut i32,
17930 vindex: __m256i,
17931 a: __m256i,
17932) {
17933 static_assert_imm8_scale!(SCALE);
17934 vpscatterdd_256(base_addr as _, 0xff, vindex.as_i32x8(), a.as_i32x8(), SCALE)
17935}
17936
17937#[inline]
17943#[target_feature(enable = "avx512f,avx512vl")]
17944#[cfg_attr(test, assert_instr(vpscatterdd, SCALE = 1))]
17945#[rustc_legacy_const_generics(4)]
17946#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17947pub unsafe fn _mm256_mask_i32scatter_epi32<const SCALE: i32>(
17948 base_addr: *mut i32,
17949 k: __mmask8,
17950 vindex: __m256i,
17951 a: __m256i,
17952) {
17953 static_assert_imm8_scale!(SCALE);
17954 vpscatterdd_256(base_addr as _, k, vindex.as_i32x8(), a.as_i32x8(), SCALE)
17955}
17956
17957#[inline]
17961#[target_feature(enable = "avx512f,avx512vl")]
17962#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17963#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
17964#[rustc_legacy_const_generics(3)]
17965pub unsafe fn _mm256_i32scatter_epi64<const SCALE: i32>(
17966 slice: *mut i64,
17967 offsets: __m128i,
17968 src: __m256i,
17969) {
17970 static_assert_imm8_scale!(SCALE);
17971 let src = src.as_i64x4();
17972 let slice = slice as *mut i8;
17973 let offsets = offsets.as_i32x4();
17974 vpscatterdq_256(slice, 0xff, offsets, src, SCALE);
17975}
17976
17977#[inline]
17983#[target_feature(enable = "avx512f,avx512vl")]
17984#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
17985#[rustc_legacy_const_generics(4)]
17986#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
17987pub unsafe fn _mm256_mask_i32scatter_epi64<const SCALE: i32>(
17988 base_addr: *mut i64,
17989 k: __mmask8,
17990 vindex: __m128i,
17991 a: __m256i,
17992) {
17993 static_assert_imm8_scale!(SCALE);
17994 vpscatterdq_256(base_addr as _, k, vindex.as_i32x4(), a.as_i64x4(), SCALE)
17995}
17996
17997#[inline]
18002#[target_feature(enable = "avx512f,avx512vl")]
18003#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
18004#[rustc_legacy_const_generics(3)]
18005#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18006pub unsafe fn _mm256_i32scatter_pd<const SCALE: i32>(
18007 base_addr: *mut f64,
18008 vindex: __m128i,
18009 a: __m256d,
18010) {
18011 static_assert_imm8_scale!(SCALE);
18012 vscatterdpd_256(base_addr as _, 0xff, vindex.as_i32x4(), a.as_f64x4(), SCALE)
18013}
18014
18015#[inline]
18021#[target_feature(enable = "avx512f,avx512vl")]
18022#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
18023#[rustc_legacy_const_generics(4)]
18024#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18025pub unsafe fn _mm256_mask_i32scatter_pd<const SCALE: i32>(
18026 base_addr: *mut f64,
18027 k: __mmask8,
18028 vindex: __m128i,
18029 a: __m256d,
18030) {
18031 static_assert_imm8_scale!(SCALE);
18032 vscatterdpd_256(base_addr as _, k, vindex.as_i32x4(), a.as_f64x4(), SCALE)
18033}
18034
18035#[inline]
18040#[target_feature(enable = "avx512f,avx512vl")]
18041#[cfg_attr(test, assert_instr(vscatterdps, SCALE = 1))]
18042#[rustc_legacy_const_generics(3)]
18043#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18044pub unsafe fn _mm256_i32scatter_ps<const SCALE: i32>(
18045 base_addr: *mut f32,
18046 vindex: __m256i,
18047 a: __m256,
18048) {
18049 static_assert_imm8_scale!(SCALE);
18050 vscatterdps_256(base_addr as _, 0xff, vindex.as_i32x8(), a.as_f32x8(), SCALE)
18051}
18052
18053#[inline]
18059#[target_feature(enable = "avx512f,avx512vl")]
18060#[cfg_attr(test, assert_instr(vscatterdps, SCALE = 1))]
18061#[rustc_legacy_const_generics(4)]
18062#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18063pub unsafe fn _mm256_mask_i32scatter_ps<const SCALE: i32>(
18064 base_addr: *mut f32,
18065 k: __mmask8,
18066 vindex: __m256i,
18067 a: __m256,
18068) {
18069 static_assert_imm8_scale!(SCALE);
18070 vscatterdps_256(base_addr as _, k, vindex.as_i32x8(), a.as_f32x8(), SCALE)
18071}
18072
18073#[inline]
18078#[target_feature(enable = "avx512f,avx512vl")]
18079#[cfg_attr(test, assert_instr(vpscatterqd, SCALE = 1))]
18080#[rustc_legacy_const_generics(3)]
18081#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18082pub unsafe fn _mm256_i64scatter_epi32<const SCALE: i32>(
18083 base_addr: *mut i32,
18084 vindex: __m256i,
18085 a: __m128i,
18086) {
18087 static_assert_imm8_scale!(SCALE);
18088 vpscatterqd_256(base_addr as _, 0xff, vindex.as_i64x4(), a.as_i32x4(), SCALE)
18089}
18090
18091#[inline]
18097#[target_feature(enable = "avx512f,avx512vl")]
18098#[cfg_attr(test, assert_instr(vpscatterqd, SCALE = 1))]
18099#[rustc_legacy_const_generics(4)]
18100#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18101pub unsafe fn _mm256_mask_i64scatter_epi32<const SCALE: i32>(
18102 base_addr: *mut i32,
18103 k: __mmask8,
18104 vindex: __m256i,
18105 a: __m128i,
18106) {
18107 static_assert_imm8_scale!(SCALE);
18108 vpscatterqd_256(base_addr as _, k, vindex.as_i64x4(), a.as_i32x4(), SCALE)
18109}
18110
18111#[inline]
18116#[target_feature(enable = "avx512f,avx512vl")]
18117#[cfg_attr(test, assert_instr(vpscatterqq, SCALE = 1))]
18118#[rustc_legacy_const_generics(3)]
18119#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18120pub unsafe fn _mm256_i64scatter_epi64<const SCALE: i32>(
18121 base_addr: *mut i64,
18122 vindex: __m256i,
18123 a: __m256i,
18124) {
18125 static_assert_imm8_scale!(SCALE);
18126 vpscatterqq_256(base_addr as _, 0xff, vindex.as_i64x4(), a.as_i64x4(), SCALE)
18127}
18128
18129#[inline]
18135#[target_feature(enable = "avx512f,avx512vl")]
18136#[cfg_attr(test, assert_instr(vpscatterqq, SCALE = 1))]
18137#[rustc_legacy_const_generics(4)]
18138#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18139pub unsafe fn _mm256_mask_i64scatter_epi64<const SCALE: i32>(
18140 base_addr: *mut i64,
18141 k: __mmask8,
18142 vindex: __m256i,
18143 a: __m256i,
18144) {
18145 static_assert_imm8_scale!(SCALE);
18146 vpscatterqq_256(base_addr as _, k, vindex.as_i64x4(), a.as_i64x4(), SCALE)
18147}
18148
18149#[inline]
18154#[target_feature(enable = "avx512f,avx512vl")]
18155#[cfg_attr(test, assert_instr(vscatterqpd, SCALE = 1))]
18156#[rustc_legacy_const_generics(3)]
18157#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18158pub unsafe fn _mm256_i64scatter_pd<const SCALE: i32>(
18159 base_addr: *mut f64,
18160 vindex: __m256i,
18161 a: __m256d,
18162) {
18163 static_assert_imm8_scale!(SCALE);
18164 vscatterqpd_256(base_addr as _, 0xff, vindex.as_i64x4(), a.as_f64x4(), SCALE)
18165}
18166
18167#[inline]
18173#[target_feature(enable = "avx512f,avx512vl")]
18174#[cfg_attr(test, assert_instr(vscatterqpd, SCALE = 1))]
18175#[rustc_legacy_const_generics(4)]
18176#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18177pub unsafe fn _mm256_mask_i64scatter_pd<const SCALE: i32>(
18178 base_addr: *mut f64,
18179 k: __mmask8,
18180 vindex: __m256i,
18181 a: __m256d,
18182) {
18183 static_assert_imm8_scale!(SCALE);
18184 vscatterqpd_256(base_addr as _, k, vindex.as_i64x4(), a.as_f64x4(), SCALE)
18185}
18186
18187#[inline]
18192#[target_feature(enable = "avx512f,avx512vl")]
18193#[cfg_attr(test, assert_instr(vscatterqps, SCALE = 1))]
18194#[rustc_legacy_const_generics(3)]
18195#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18196pub unsafe fn _mm256_i64scatter_ps<const SCALE: i32>(
18197 base_addr: *mut f32,
18198 vindex: __m256i,
18199 a: __m128,
18200) {
18201 static_assert_imm8_scale!(SCALE);
18202 vscatterqps_256(base_addr as _, 0xff, vindex.as_i64x4(), a.as_f32x4(), SCALE)
18203}
18204
18205#[inline]
18211#[target_feature(enable = "avx512f,avx512vl")]
18212#[cfg_attr(test, assert_instr(vscatterqps, SCALE = 1))]
18213#[rustc_legacy_const_generics(4)]
18214#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18215pub unsafe fn _mm256_mask_i64scatter_ps<const SCALE: i32>(
18216 base_addr: *mut f32,
18217 k: __mmask8,
18218 vindex: __m256i,
18219 a: __m128,
18220) {
18221 static_assert_imm8_scale!(SCALE);
18222 vscatterqps_256(base_addr as _, k, vindex.as_i64x4(), a.as_f32x4(), SCALE)
18223}
18224
18225#[inline]
18231#[target_feature(enable = "avx512f,avx512vl")]
18232#[cfg_attr(test, assert_instr(vpgatherdd, SCALE = 1))]
18233#[rustc_legacy_const_generics(4)]
18234#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18235pub unsafe fn _mm256_mmask_i32gather_epi32<const SCALE: i32>(
18236 src: __m256i,
18237 k: __mmask8,
18238 vindex: __m256i,
18239 base_addr: *const i32,
18240) -> __m256i {
18241 static_assert_imm8_scale!(SCALE);
18242 transmute(vpgatherdd_256(
18243 src.as_i32x8(),
18244 base_addr as _,
18245 vindex.as_i32x8(),
18246 k,
18247 SCALE,
18248 ))
18249}
18250
18251#[inline]
18257#[target_feature(enable = "avx512f,avx512vl")]
18258#[cfg_attr(test, assert_instr(vpgatherdq, SCALE = 1))]
18259#[rustc_legacy_const_generics(4)]
18260#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18261pub unsafe fn _mm256_mmask_i32gather_epi64<const SCALE: i32>(
18262 src: __m256i,
18263 k: __mmask8,
18264 vindex: __m128i,
18265 base_addr: *const i64,
18266) -> __m256i {
18267 static_assert_imm8_scale!(SCALE);
18268 transmute(vpgatherdq_256(
18269 src.as_i64x4(),
18270 base_addr as _,
18271 vindex.as_i32x4(),
18272 k,
18273 SCALE,
18274 ))
18275}
18276
18277#[inline]
18283#[target_feature(enable = "avx512f,avx512vl")]
18284#[cfg_attr(test, assert_instr(vgatherdpd, SCALE = 1))]
18285#[rustc_legacy_const_generics(4)]
18286#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18287pub unsafe fn _mm256_mmask_i32gather_pd<const SCALE: i32>(
18288 src: __m256d,
18289 k: __mmask8,
18290 vindex: __m128i,
18291 base_addr: *const f64,
18292) -> __m256d {
18293 static_assert_imm8_scale!(SCALE);
18294 transmute(vgatherdpd_256(
18295 src.as_f64x4(),
18296 base_addr as _,
18297 vindex.as_i32x4(),
18298 k,
18299 SCALE,
18300 ))
18301}
18302
18303#[inline]
18309#[target_feature(enable = "avx512f,avx512vl")]
18310#[cfg_attr(test, assert_instr(vgatherdps, SCALE = 1))]
18311#[rustc_legacy_const_generics(4)]
18312#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18313pub unsafe fn _mm256_mmask_i32gather_ps<const SCALE: i32>(
18314 src: __m256,
18315 k: __mmask8,
18316 vindex: __m256i,
18317 base_addr: *const f32,
18318) -> __m256 {
18319 static_assert_imm8_scale!(SCALE);
18320 transmute(vgatherdps_256(
18321 src.as_f32x8(),
18322 base_addr as _,
18323 vindex.as_i32x8(),
18324 k,
18325 SCALE,
18326 ))
18327}
18328
18329#[inline]
18335#[target_feature(enable = "avx512f,avx512vl")]
18336#[cfg_attr(test, assert_instr(vpgatherqd, SCALE = 1))]
18337#[rustc_legacy_const_generics(4)]
18338#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18339pub unsafe fn _mm256_mmask_i64gather_epi32<const SCALE: i32>(
18340 src: __m128i,
18341 k: __mmask8,
18342 vindex: __m256i,
18343 base_addr: *const i32,
18344) -> __m128i {
18345 static_assert_imm8_scale!(SCALE);
18346 transmute(vpgatherqd_256(
18347 src.as_i32x4(),
18348 base_addr as _,
18349 vindex.as_i64x4(),
18350 k,
18351 SCALE,
18352 ))
18353}
18354
18355#[inline]
18361#[target_feature(enable = "avx512f,avx512vl")]
18362#[cfg_attr(test, assert_instr(vpgatherqq, SCALE = 1))]
18363#[rustc_legacy_const_generics(4)]
18364#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18365pub unsafe fn _mm256_mmask_i64gather_epi64<const SCALE: i32>(
18366 src: __m256i,
18367 k: __mmask8,
18368 vindex: __m256i,
18369 base_addr: *const i64,
18370) -> __m256i {
18371 static_assert_imm8_scale!(SCALE);
18372 transmute(vpgatherqq_256(
18373 src.as_i64x4(),
18374 base_addr as _,
18375 vindex.as_i64x4(),
18376 k,
18377 SCALE,
18378 ))
18379}
18380
18381#[inline]
18387#[target_feature(enable = "avx512f,avx512vl")]
18388#[cfg_attr(test, assert_instr(vgatherqpd, SCALE = 1))]
18389#[rustc_legacy_const_generics(4)]
18390#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18391pub unsafe fn _mm256_mmask_i64gather_pd<const SCALE: i32>(
18392 src: __m256d,
18393 k: __mmask8,
18394 vindex: __m256i,
18395 base_addr: *const f64,
18396) -> __m256d {
18397 static_assert_imm8_scale!(SCALE);
18398 transmute(vgatherqpd_256(
18399 src.as_f64x4(),
18400 base_addr as _,
18401 vindex.as_i64x4(),
18402 k,
18403 SCALE,
18404 ))
18405}
18406
18407#[inline]
18413#[target_feature(enable = "avx512f,avx512vl")]
18414#[cfg_attr(test, assert_instr(vgatherqps, SCALE = 1))]
18415#[rustc_legacy_const_generics(4)]
18416#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18417pub unsafe fn _mm256_mmask_i64gather_ps<const SCALE: i32>(
18418 src: __m128,
18419 k: __mmask8,
18420 vindex: __m256i,
18421 base_addr: *const f32,
18422) -> __m128 {
18423 static_assert_imm8_scale!(SCALE);
18424 transmute(vgatherqps_256(
18425 src.as_f32x4(),
18426 base_addr as _,
18427 vindex.as_i64x4(),
18428 k,
18429 SCALE,
18430 ))
18431}
18432
18433#[inline]
18438#[target_feature(enable = "avx512f,avx512vl")]
18439#[cfg_attr(test, assert_instr(vpscatterdd, SCALE = 1))]
18440#[rustc_legacy_const_generics(3)]
18441#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18442pub unsafe fn _mm_i32scatter_epi32<const SCALE: i32>(
18443 base_addr: *mut i32,
18444 vindex: __m128i,
18445 a: __m128i,
18446) {
18447 static_assert_imm8_scale!(SCALE);
18448 vpscatterdd_128(base_addr as _, 0xff, vindex.as_i32x4(), a.as_i32x4(), SCALE)
18449}
18450
18451#[inline]
18457#[target_feature(enable = "avx512f,avx512vl")]
18458#[cfg_attr(test, assert_instr(vpscatterdd, SCALE = 1))]
18459#[rustc_legacy_const_generics(4)]
18460#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18461pub unsafe fn _mm_mask_i32scatter_epi32<const SCALE: i32>(
18462 base_addr: *mut i32,
18463 k: __mmask8,
18464 vindex: __m128i,
18465 a: __m128i,
18466) {
18467 static_assert_imm8_scale!(SCALE);
18468 vpscatterdd_128(base_addr as _, k, vindex.as_i32x4(), a.as_i32x4(), SCALE)
18469}
18470
18471#[inline]
18476#[target_feature(enable = "avx512f,avx512vl")]
18477#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
18478#[rustc_legacy_const_generics(3)]
18479#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18480pub unsafe fn _mm_i32scatter_epi64<const SCALE: i32>(
18481 base_addr: *mut i64,
18482 vindex: __m128i,
18483 a: __m128i,
18484) {
18485 static_assert_imm8_scale!(SCALE);
18486 vpscatterdq_128(base_addr as _, 0xff, vindex.as_i32x4(), a.as_i64x2(), SCALE)
18487}
18488
18489#[inline]
18495#[target_feature(enable = "avx512f,avx512vl")]
18496#[cfg_attr(test, assert_instr(vpscatterdq, SCALE = 1))]
18497#[rustc_legacy_const_generics(4)]
18498#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18499pub unsafe fn _mm_mask_i32scatter_epi64<const SCALE: i32>(
18500 base_addr: *mut i64,
18501 k: __mmask8,
18502 vindex: __m128i,
18503 a: __m128i,
18504) {
18505 static_assert_imm8_scale!(SCALE);
18506 vpscatterdq_128(base_addr as _, k, vindex.as_i32x4(), a.as_i64x2(), SCALE)
18507}
18508
18509#[inline]
18514#[target_feature(enable = "avx512f,avx512vl")]
18515#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
18516#[rustc_legacy_const_generics(3)]
18517#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18518pub unsafe fn _mm_i32scatter_pd<const SCALE: i32>(
18519 base_addr: *mut f64,
18520 vindex: __m128i,
18521 a: __m128d,
18522) {
18523 static_assert_imm8_scale!(SCALE);
18524 vscatterdpd_128(base_addr as _, 0xff, vindex.as_i32x4(), a.as_f64x2(), SCALE)
18525}
18526
18527#[inline]
18533#[target_feature(enable = "avx512f,avx512vl")]
18534#[cfg_attr(test, assert_instr(vscatterdpd, SCALE = 1))]
18535#[rustc_legacy_const_generics(4)]
18536#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18537pub unsafe fn _mm_mask_i32scatter_pd<const SCALE: i32>(
18538 base_addr: *mut f64,
18539 k: __mmask8,
18540 vindex: __m128i,
18541 a: __m128d,
18542) {
18543 static_assert_imm8_scale!(SCALE);
18544 vscatterdpd_128(base_addr as _, k, vindex.as_i32x4(), a.as_f64x2(), SCALE)
18545}
18546
18547#[inline]
18552#[target_feature(enable = "avx512f,avx512vl")]
18553#[cfg_attr(test, assert_instr(vscatterdps, SCALE = 1))]
18554#[rustc_legacy_const_generics(3)]
18555#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18556pub unsafe fn _mm_i32scatter_ps<const SCALE: i32>(base_addr: *mut f32, vindex: __m128i, a: __m128) {
18557 static_assert_imm8_scale!(SCALE);
18558 vscatterdps_128(base_addr as _, 0xff, vindex.as_i32x4(), a.as_f32x4(), SCALE)
18559}
18560
18561#[inline]
18567#[target_feature(enable = "avx512f,avx512vl")]
18568#[cfg_attr(test, assert_instr(vscatterdps, SCALE = 1))]
18569#[rustc_legacy_const_generics(4)]
18570#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18571pub unsafe fn _mm_mask_i32scatter_ps<const SCALE: i32>(
18572 base_addr: *mut f32,
18573 k: __mmask8,
18574 vindex: __m128i,
18575 a: __m128,
18576) {
18577 static_assert_imm8_scale!(SCALE);
18578 vscatterdps_128(base_addr as _, k, vindex.as_i32x4(), a.as_f32x4(), SCALE)
18579}
18580
18581#[inline]
18586#[target_feature(enable = "avx512f,avx512vl")]
18587#[cfg_attr(test, assert_instr(vpscatterqd, SCALE = 1))]
18588#[rustc_legacy_const_generics(3)]
18589#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18590pub unsafe fn _mm_i64scatter_epi32<const SCALE: i32>(
18591 base_addr: *mut i32,
18592 vindex: __m128i,
18593 a: __m128i,
18594) {
18595 static_assert_imm8_scale!(SCALE);
18596 vpscatterqd_128(base_addr as _, 0xff, vindex.as_i64x2(), a.as_i32x4(), SCALE)
18597}
18598
18599#[inline]
18605#[target_feature(enable = "avx512f,avx512vl")]
18606#[cfg_attr(test, assert_instr(vpscatterqd, SCALE = 1))]
18607#[rustc_legacy_const_generics(4)]
18608#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18609pub unsafe fn _mm_mask_i64scatter_epi32<const SCALE: i32>(
18610 base_addr: *mut i32,
18611 k: __mmask8,
18612 vindex: __m128i,
18613 a: __m128i,
18614) {
18615 static_assert_imm8_scale!(SCALE);
18616 vpscatterqd_128(base_addr as _, k, vindex.as_i64x2(), a.as_i32x4(), SCALE)
18617}
18618
18619#[inline]
18624#[target_feature(enable = "avx512f,avx512vl")]
18625#[cfg_attr(test, assert_instr(vpscatterqq, SCALE = 1))]
18626#[rustc_legacy_const_generics(3)]
18627#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18628pub unsafe fn _mm_i64scatter_epi64<const SCALE: i32>(
18629 base_addr: *mut i64,
18630 vindex: __m128i,
18631 a: __m128i,
18632) {
18633 static_assert_imm8_scale!(SCALE);
18634 vpscatterqq_128(base_addr as _, 0xff, vindex.as_i64x2(), a.as_i64x2(), SCALE)
18635}
18636
18637#[inline]
18643#[target_feature(enable = "avx512f,avx512vl")]
18644#[cfg_attr(test, assert_instr(vpscatterqq, SCALE = 1))]
18645#[rustc_legacy_const_generics(4)]
18646#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18647pub unsafe fn _mm_mask_i64scatter_epi64<const SCALE: i32>(
18648 base_addr: *mut i64,
18649 k: __mmask8,
18650 vindex: __m128i,
18651 a: __m128i,
18652) {
18653 static_assert_imm8_scale!(SCALE);
18654 vpscatterqq_128(base_addr as _, k, vindex.as_i64x2(), a.as_i64x2(), SCALE)
18655}
18656
18657#[inline]
18662#[target_feature(enable = "avx512f,avx512vl")]
18663#[cfg_attr(test, assert_instr(vscatterqpd, SCALE = 1))]
18664#[rustc_legacy_const_generics(3)]
18665#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18666pub unsafe fn _mm_i64scatter_pd<const SCALE: i32>(
18667 base_addr: *mut f64,
18668 vindex: __m128i,
18669 a: __m128d,
18670) {
18671 static_assert_imm8_scale!(SCALE);
18672 vscatterqpd_128(base_addr as _, 0xff, vindex.as_i64x2(), a.as_f64x2(), SCALE)
18673}
18674
18675#[inline]
18681#[target_feature(enable = "avx512f,avx512vl")]
18682#[cfg_attr(test, assert_instr(vscatterqpd, SCALE = 1))]
18683#[rustc_legacy_const_generics(4)]
18684#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18685pub unsafe fn _mm_mask_i64scatter_pd<const SCALE: i32>(
18686 base_addr: *mut f64,
18687 k: __mmask8,
18688 vindex: __m128i,
18689 a: __m128d,
18690) {
18691 static_assert_imm8_scale!(SCALE);
18692 vscatterqpd_128(base_addr as _, k, vindex.as_i64x2(), a.as_f64x2(), SCALE)
18693}
18694
18695#[inline]
18700#[target_feature(enable = "avx512f,avx512vl")]
18701#[cfg_attr(test, assert_instr(vscatterqps, SCALE = 1))]
18702#[rustc_legacy_const_generics(3)]
18703#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18704pub unsafe fn _mm_i64scatter_ps<const SCALE: i32>(base_addr: *mut f32, vindex: __m128i, a: __m128) {
18705 static_assert_imm8_scale!(SCALE);
18706 vscatterqps_128(base_addr as _, 0xff, vindex.as_i64x2(), a.as_f32x4(), SCALE)
18707}
18708
18709#[inline]
18714#[target_feature(enable = "avx512f,avx512vl")]
18715#[cfg_attr(test, assert_instr(vscatterqps, SCALE = 1))]
18716#[rustc_legacy_const_generics(4)]
18717#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18718pub unsafe fn _mm_mask_i64scatter_ps<const SCALE: i32>(
18719 base_addr: *mut f32,
18720 k: __mmask8,
18721 vindex: __m128i,
18722 a: __m128,
18723) {
18724 static_assert_imm8_scale!(SCALE);
18725 vscatterqps_128(base_addr as _, k, vindex.as_i64x2(), a.as_f32x4(), SCALE)
18726}
18727
18728#[inline]
18734#[target_feature(enable = "avx512f,avx512vl")]
18735#[cfg_attr(test, assert_instr(vpgatherdd, SCALE = 1))]
18736#[rustc_legacy_const_generics(4)]
18737#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18738pub unsafe fn _mm_mmask_i32gather_epi32<const SCALE: i32>(
18739 src: __m128i,
18740 k: __mmask8,
18741 vindex: __m128i,
18742 base_addr: *const i32,
18743) -> __m128i {
18744 static_assert_imm8_scale!(SCALE);
18745 transmute(vpgatherdd_128(
18746 src.as_i32x4(),
18747 base_addr as _,
18748 vindex.as_i32x4(),
18749 k,
18750 SCALE,
18751 ))
18752}
18753
18754#[inline]
18760#[target_feature(enable = "avx512f,avx512vl")]
18761#[cfg_attr(test, assert_instr(vpgatherdq, SCALE = 1))]
18762#[rustc_legacy_const_generics(4)]
18763#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18764pub unsafe fn _mm_mmask_i32gather_epi64<const SCALE: i32>(
18765 src: __m128i,
18766 k: __mmask8,
18767 vindex: __m128i,
18768 base_addr: *const i64,
18769) -> __m128i {
18770 static_assert_imm8_scale!(SCALE);
18771 transmute(vpgatherdq_128(
18772 src.as_i64x2(),
18773 base_addr as _,
18774 vindex.as_i32x4(),
18775 k,
18776 SCALE,
18777 ))
18778}
18779
18780#[inline]
18786#[target_feature(enable = "avx512f,avx512vl")]
18787#[cfg_attr(test, assert_instr(vgatherdpd, SCALE = 1))]
18788#[rustc_legacy_const_generics(4)]
18789#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18790pub unsafe fn _mm_mmask_i32gather_pd<const SCALE: i32>(
18791 src: __m128d,
18792 k: __mmask8,
18793 vindex: __m128i,
18794 base_addr: *const f64,
18795) -> __m128d {
18796 static_assert_imm8_scale!(SCALE);
18797 transmute(vgatherdpd_128(
18798 src.as_f64x2(),
18799 base_addr as _,
18800 vindex.as_i32x4(),
18801 k,
18802 SCALE,
18803 ))
18804}
18805
18806#[inline]
18812#[target_feature(enable = "avx512f,avx512vl")]
18813#[cfg_attr(test, assert_instr(vgatherdps, SCALE = 1))]
18814#[rustc_legacy_const_generics(4)]
18815#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18816pub unsafe fn _mm_mmask_i32gather_ps<const SCALE: i32>(
18817 src: __m128,
18818 k: __mmask8,
18819 vindex: __m128i,
18820 base_addr: *const f32,
18821) -> __m128 {
18822 static_assert_imm8_scale!(SCALE);
18823 transmute(vgatherdps_128(
18824 src.as_f32x4(),
18825 base_addr as _,
18826 vindex.as_i32x4(),
18827 k,
18828 SCALE,
18829 ))
18830}
18831
18832#[inline]
18838#[target_feature(enable = "avx512f,avx512vl")]
18839#[cfg_attr(test, assert_instr(vpgatherqd, SCALE = 1))]
18840#[rustc_legacy_const_generics(4)]
18841#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18842pub unsafe fn _mm_mmask_i64gather_epi32<const SCALE: i32>(
18843 src: __m128i,
18844 k: __mmask8,
18845 vindex: __m128i,
18846 base_addr: *const i32,
18847) -> __m128i {
18848 static_assert_imm8_scale!(SCALE);
18849 transmute(vpgatherqd_128(
18850 src.as_i32x4(),
18851 base_addr as _,
18852 vindex.as_i64x2(),
18853 k,
18854 SCALE,
18855 ))
18856}
18857
18858#[inline]
18864#[target_feature(enable = "avx512f,avx512vl")]
18865#[cfg_attr(test, assert_instr(vpgatherqq, SCALE = 1))]
18866#[rustc_legacy_const_generics(4)]
18867#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18868pub unsafe fn _mm_mmask_i64gather_epi64<const SCALE: i32>(
18869 src: __m128i,
18870 k: __mmask8,
18871 vindex: __m128i,
18872 base_addr: *const i64,
18873) -> __m128i {
18874 static_assert_imm8_scale!(SCALE);
18875 transmute(vpgatherqq_128(
18876 src.as_i64x2(),
18877 base_addr as _,
18878 vindex.as_i64x2(),
18879 k,
18880 SCALE,
18881 ))
18882}
18883
18884#[inline]
18890#[target_feature(enable = "avx512f,avx512vl")]
18891#[cfg_attr(test, assert_instr(vgatherqpd, SCALE = 1))]
18892#[rustc_legacy_const_generics(4)]
18893#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18894pub unsafe fn _mm_mmask_i64gather_pd<const SCALE: i32>(
18895 src: __m128d,
18896 k: __mmask8,
18897 vindex: __m128i,
18898 base_addr: *const f64,
18899) -> __m128d {
18900 static_assert_imm8_scale!(SCALE);
18901 transmute(vgatherqpd_128(
18902 src.as_f64x2(),
18903 base_addr as _,
18904 vindex.as_i64x2(),
18905 k,
18906 SCALE,
18907 ))
18908}
18909
18910#[inline]
18916#[target_feature(enable = "avx512f,avx512vl")]
18917#[cfg_attr(test, assert_instr(vgatherqps, SCALE = 1))]
18918#[rustc_legacy_const_generics(4)]
18919#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18920pub unsafe fn _mm_mmask_i64gather_ps<const SCALE: i32>(
18921 src: __m128,
18922 k: __mmask8,
18923 vindex: __m128i,
18924 base_addr: *const f32,
18925) -> __m128 {
18926 static_assert_imm8_scale!(SCALE);
18927 transmute(vgatherqps_128(
18928 src.as_f32x4(),
18929 base_addr as _,
18930 vindex.as_i64x2(),
18931 k,
18932 SCALE,
18933 ))
18934}
18935
18936#[inline]
18940#[target_feature(enable = "avx512f")]
18941#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18942#[cfg_attr(test, assert_instr(vpcompressd))]
18943pub fn _mm512_mask_compress_epi32(src: __m512i, k: __mmask16, a: __m512i) -> __m512i {
18944 unsafe { transmute(vpcompressd(a.as_i32x16(), src.as_i32x16(), k)) }
18945}
18946
18947#[inline]
18951#[target_feature(enable = "avx512f")]
18952#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18953#[cfg_attr(test, assert_instr(vpcompressd))]
18954pub fn _mm512_maskz_compress_epi32(k: __mmask16, a: __m512i) -> __m512i {
18955 unsafe { transmute(vpcompressd(a.as_i32x16(), i32x16::ZERO, k)) }
18956}
18957
18958#[inline]
18962#[target_feature(enable = "avx512f,avx512vl")]
18963#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18964#[cfg_attr(test, assert_instr(vpcompressd))]
18965pub fn _mm256_mask_compress_epi32(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
18966 unsafe { transmute(vpcompressd256(a.as_i32x8(), src.as_i32x8(), k)) }
18967}
18968
18969#[inline]
18973#[target_feature(enable = "avx512f,avx512vl")]
18974#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18975#[cfg_attr(test, assert_instr(vpcompressd))]
18976pub fn _mm256_maskz_compress_epi32(k: __mmask8, a: __m256i) -> __m256i {
18977 unsafe { transmute(vpcompressd256(a.as_i32x8(), i32x8::ZERO, k)) }
18978}
18979
18980#[inline]
18984#[target_feature(enable = "avx512f,avx512vl")]
18985#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18986#[cfg_attr(test, assert_instr(vpcompressd))]
18987pub fn _mm_mask_compress_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
18988 unsafe { transmute(vpcompressd128(a.as_i32x4(), src.as_i32x4(), k)) }
18989}
18990
18991#[inline]
18995#[target_feature(enable = "avx512f,avx512vl")]
18996#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
18997#[cfg_attr(test, assert_instr(vpcompressd))]
18998pub fn _mm_maskz_compress_epi32(k: __mmask8, a: __m128i) -> __m128i {
18999 unsafe { transmute(vpcompressd128(a.as_i32x4(), i32x4::ZERO, k)) }
19000}
19001
19002#[inline]
19006#[target_feature(enable = "avx512f")]
19007#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19008#[cfg_attr(test, assert_instr(vpcompressq))]
19009pub fn _mm512_mask_compress_epi64(src: __m512i, k: __mmask8, a: __m512i) -> __m512i {
19010 unsafe { transmute(vpcompressq(a.as_i64x8(), src.as_i64x8(), k)) }
19011}
19012
19013#[inline]
19017#[target_feature(enable = "avx512f")]
19018#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19019#[cfg_attr(test, assert_instr(vpcompressq))]
19020pub fn _mm512_maskz_compress_epi64(k: __mmask8, a: __m512i) -> __m512i {
19021 unsafe { transmute(vpcompressq(a.as_i64x8(), i64x8::ZERO, k)) }
19022}
19023
19024#[inline]
19028#[target_feature(enable = "avx512f,avx512vl")]
19029#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19030#[cfg_attr(test, assert_instr(vpcompressq))]
19031pub fn _mm256_mask_compress_epi64(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
19032 unsafe { transmute(vpcompressq256(a.as_i64x4(), src.as_i64x4(), k)) }
19033}
19034
19035#[inline]
19039#[target_feature(enable = "avx512f,avx512vl")]
19040#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19041#[cfg_attr(test, assert_instr(vpcompressq))]
19042pub fn _mm256_maskz_compress_epi64(k: __mmask8, a: __m256i) -> __m256i {
19043 unsafe { transmute(vpcompressq256(a.as_i64x4(), i64x4::ZERO, k)) }
19044}
19045
19046#[inline]
19050#[target_feature(enable = "avx512f,avx512vl")]
19051#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19052#[cfg_attr(test, assert_instr(vpcompressq))]
19053pub fn _mm_mask_compress_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
19054 unsafe { transmute(vpcompressq128(a.as_i64x2(), src.as_i64x2(), k)) }
19055}
19056
19057#[inline]
19061#[target_feature(enable = "avx512f,avx512vl")]
19062#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19063#[cfg_attr(test, assert_instr(vpcompressq))]
19064pub fn _mm_maskz_compress_epi64(k: __mmask8, a: __m128i) -> __m128i {
19065 unsafe { transmute(vpcompressq128(a.as_i64x2(), i64x2::ZERO, k)) }
19066}
19067
19068#[inline]
19072#[target_feature(enable = "avx512f")]
19073#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19074#[cfg_attr(test, assert_instr(vcompressps))]
19075pub fn _mm512_mask_compress_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
19076 unsafe { transmute(vcompressps(a.as_f32x16(), src.as_f32x16(), k)) }
19077}
19078
19079#[inline]
19083#[target_feature(enable = "avx512f")]
19084#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19085#[cfg_attr(test, assert_instr(vcompressps))]
19086pub fn _mm512_maskz_compress_ps(k: __mmask16, a: __m512) -> __m512 {
19087 unsafe { transmute(vcompressps(a.as_f32x16(), f32x16::ZERO, k)) }
19088}
19089
19090#[inline]
19094#[target_feature(enable = "avx512f,avx512vl")]
19095#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19096#[cfg_attr(test, assert_instr(vcompressps))]
19097pub fn _mm256_mask_compress_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
19098 unsafe { transmute(vcompressps256(a.as_f32x8(), src.as_f32x8(), k)) }
19099}
19100
19101#[inline]
19105#[target_feature(enable = "avx512f,avx512vl")]
19106#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19107#[cfg_attr(test, assert_instr(vcompressps))]
19108pub fn _mm256_maskz_compress_ps(k: __mmask8, a: __m256) -> __m256 {
19109 unsafe { transmute(vcompressps256(a.as_f32x8(), f32x8::ZERO, k)) }
19110}
19111
19112#[inline]
19116#[target_feature(enable = "avx512f,avx512vl")]
19117#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19118#[cfg_attr(test, assert_instr(vcompressps))]
19119pub fn _mm_mask_compress_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
19120 unsafe { transmute(vcompressps128(a.as_f32x4(), src.as_f32x4(), k)) }
19121}
19122
19123#[inline]
19127#[target_feature(enable = "avx512f,avx512vl")]
19128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19129#[cfg_attr(test, assert_instr(vcompressps))]
19130pub fn _mm_maskz_compress_ps(k: __mmask8, a: __m128) -> __m128 {
19131 unsafe { transmute(vcompressps128(a.as_f32x4(), f32x4::ZERO, k)) }
19132}
19133
19134#[inline]
19138#[target_feature(enable = "avx512f")]
19139#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19140#[cfg_attr(test, assert_instr(vcompresspd))]
19141pub fn _mm512_mask_compress_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
19142 unsafe { transmute(vcompresspd(a.as_f64x8(), src.as_f64x8(), k)) }
19143}
19144
19145#[inline]
19149#[target_feature(enable = "avx512f")]
19150#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19151#[cfg_attr(test, assert_instr(vcompresspd))]
19152pub fn _mm512_maskz_compress_pd(k: __mmask8, a: __m512d) -> __m512d {
19153 unsafe { transmute(vcompresspd(a.as_f64x8(), f64x8::ZERO, k)) }
19154}
19155
19156#[inline]
19160#[target_feature(enable = "avx512f,avx512vl")]
19161#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19162#[cfg_attr(test, assert_instr(vcompresspd))]
19163pub fn _mm256_mask_compress_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
19164 unsafe { transmute(vcompresspd256(a.as_f64x4(), src.as_f64x4(), k)) }
19165}
19166
19167#[inline]
19171#[target_feature(enable = "avx512f,avx512vl")]
19172#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19173#[cfg_attr(test, assert_instr(vcompresspd))]
19174pub fn _mm256_maskz_compress_pd(k: __mmask8, a: __m256d) -> __m256d {
19175 unsafe { transmute(vcompresspd256(a.as_f64x4(), f64x4::ZERO, k)) }
19176}
19177
19178#[inline]
19182#[target_feature(enable = "avx512f,avx512vl")]
19183#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19184#[cfg_attr(test, assert_instr(vcompresspd))]
19185pub fn _mm_mask_compress_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
19186 unsafe { transmute(vcompresspd128(a.as_f64x2(), src.as_f64x2(), k)) }
19187}
19188
19189#[inline]
19193#[target_feature(enable = "avx512f,avx512vl")]
19194#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19195#[cfg_attr(test, assert_instr(vcompresspd))]
19196pub fn _mm_maskz_compress_pd(k: __mmask8, a: __m128d) -> __m128d {
19197 unsafe { transmute(vcompresspd128(a.as_f64x2(), f64x2::ZERO, k)) }
19198}
19199
19200#[inline]
19204#[target_feature(enable = "avx512f")]
19205#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19206#[cfg_attr(test, assert_instr(vpcompressd))]
19207pub unsafe fn _mm512_mask_compressstoreu_epi32(base_addr: *mut i32, k: __mmask16, a: __m512i) {
19208 vcompressstored(base_addr as *mut _, a.as_i32x16(), k)
19209}
19210
19211#[inline]
19215#[target_feature(enable = "avx512f,avx512vl")]
19216#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19217#[cfg_attr(test, assert_instr(vpcompressd))]
19218pub unsafe fn _mm256_mask_compressstoreu_epi32(base_addr: *mut i32, k: __mmask8, a: __m256i) {
19219 vcompressstored256(base_addr as *mut _, a.as_i32x8(), k)
19220}
19221
19222#[inline]
19226#[target_feature(enable = "avx512f,avx512vl")]
19227#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19228#[cfg_attr(test, assert_instr(vpcompressd))]
19229pub unsafe fn _mm_mask_compressstoreu_epi32(base_addr: *mut i32, k: __mmask8, a: __m128i) {
19230 vcompressstored128(base_addr as *mut _, a.as_i32x4(), k)
19231}
19232
19233#[inline]
19237#[target_feature(enable = "avx512f")]
19238#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19239#[cfg_attr(test, assert_instr(vpcompressq))]
19240pub unsafe fn _mm512_mask_compressstoreu_epi64(base_addr: *mut i64, k: __mmask8, a: __m512i) {
19241 vcompressstoreq(base_addr as *mut _, a.as_i64x8(), k)
19242}
19243
19244#[inline]
19248#[target_feature(enable = "avx512f,avx512vl")]
19249#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19250#[cfg_attr(test, assert_instr(vpcompressq))]
19251pub unsafe fn _mm256_mask_compressstoreu_epi64(base_addr: *mut i64, k: __mmask8, a: __m256i) {
19252 vcompressstoreq256(base_addr as *mut _, a.as_i64x4(), k)
19253}
19254
19255#[inline]
19259#[target_feature(enable = "avx512f,avx512vl")]
19260#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19261#[cfg_attr(test, assert_instr(vpcompressq))]
19262pub unsafe fn _mm_mask_compressstoreu_epi64(base_addr: *mut i64, k: __mmask8, a: __m128i) {
19263 vcompressstoreq128(base_addr as *mut _, a.as_i64x2(), k)
19264}
19265
19266#[inline]
19270#[target_feature(enable = "avx512f")]
19271#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19272#[cfg_attr(test, assert_instr(vcompressps))]
19273pub unsafe fn _mm512_mask_compressstoreu_ps(base_addr: *mut f32, k: __mmask16, a: __m512) {
19274 vcompressstoreps(base_addr as *mut _, a.as_f32x16(), k)
19275}
19276
19277#[inline]
19281#[target_feature(enable = "avx512f,avx512vl")]
19282#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19283#[cfg_attr(test, assert_instr(vcompressps))]
19284pub unsafe fn _mm256_mask_compressstoreu_ps(base_addr: *mut f32, k: __mmask8, a: __m256) {
19285 vcompressstoreps256(base_addr as *mut _, a.as_f32x8(), k)
19286}
19287
19288#[inline]
19292#[target_feature(enable = "avx512f,avx512vl")]
19293#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19294#[cfg_attr(test, assert_instr(vcompressps))]
19295pub unsafe fn _mm_mask_compressstoreu_ps(base_addr: *mut f32, k: __mmask8, a: __m128) {
19296 vcompressstoreps128(base_addr as *mut _, a.as_f32x4(), k)
19297}
19298
19299#[inline]
19303#[target_feature(enable = "avx512f")]
19304#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19305#[cfg_attr(test, assert_instr(vcompresspd))]
19306pub unsafe fn _mm512_mask_compressstoreu_pd(base_addr: *mut f64, k: __mmask8, a: __m512d) {
19307 vcompressstorepd(base_addr as *mut _, a.as_f64x8(), k)
19308}
19309
19310#[inline]
19314#[target_feature(enable = "avx512f,avx512vl")]
19315#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19316#[cfg_attr(test, assert_instr(vcompresspd))]
19317pub unsafe fn _mm256_mask_compressstoreu_pd(base_addr: *mut f64, k: __mmask8, a: __m256d) {
19318 vcompressstorepd256(base_addr as *mut _, a.as_f64x4(), k)
19319}
19320
19321#[inline]
19325#[target_feature(enable = "avx512f,avx512vl")]
19326#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19327#[cfg_attr(test, assert_instr(vcompresspd))]
19328pub unsafe fn _mm_mask_compressstoreu_pd(base_addr: *mut f64, k: __mmask8, a: __m128d) {
19329 vcompressstorepd128(base_addr as *mut _, a.as_f64x2(), k)
19330}
19331
19332#[inline]
19336#[target_feature(enable = "avx512f")]
19337#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19338#[cfg_attr(test, assert_instr(vpexpandd))]
19339pub fn _mm512_mask_expand_epi32(src: __m512i, k: __mmask16, a: __m512i) -> __m512i {
19340 unsafe { transmute(vpexpandd(a.as_i32x16(), src.as_i32x16(), k)) }
19341}
19342
19343#[inline]
19347#[target_feature(enable = "avx512f")]
19348#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19349#[cfg_attr(test, assert_instr(vpexpandd))]
19350pub fn _mm512_maskz_expand_epi32(k: __mmask16, a: __m512i) -> __m512i {
19351 unsafe { transmute(vpexpandd(a.as_i32x16(), i32x16::ZERO, k)) }
19352}
19353
19354#[inline]
19358#[target_feature(enable = "avx512f,avx512vl")]
19359#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19360#[cfg_attr(test, assert_instr(vpexpandd))]
19361pub fn _mm256_mask_expand_epi32(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
19362 unsafe { transmute(vpexpandd256(a.as_i32x8(), src.as_i32x8(), k)) }
19363}
19364
19365#[inline]
19369#[target_feature(enable = "avx512f,avx512vl")]
19370#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19371#[cfg_attr(test, assert_instr(vpexpandd))]
19372pub fn _mm256_maskz_expand_epi32(k: __mmask8, a: __m256i) -> __m256i {
19373 unsafe { transmute(vpexpandd256(a.as_i32x8(), i32x8::ZERO, k)) }
19374}
19375
19376#[inline]
19380#[target_feature(enable = "avx512f,avx512vl")]
19381#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19382#[cfg_attr(test, assert_instr(vpexpandd))]
19383pub fn _mm_mask_expand_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
19384 unsafe { transmute(vpexpandd128(a.as_i32x4(), src.as_i32x4(), k)) }
19385}
19386
19387#[inline]
19391#[target_feature(enable = "avx512f,avx512vl")]
19392#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19393#[cfg_attr(test, assert_instr(vpexpandd))]
19394pub fn _mm_maskz_expand_epi32(k: __mmask8, a: __m128i) -> __m128i {
19395 unsafe { transmute(vpexpandd128(a.as_i32x4(), i32x4::ZERO, k)) }
19396}
19397
19398#[inline]
19402#[target_feature(enable = "avx512f")]
19403#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19404#[cfg_attr(test, assert_instr(vpexpandq))]
19405pub fn _mm512_mask_expand_epi64(src: __m512i, k: __mmask8, a: __m512i) -> __m512i {
19406 unsafe { transmute(vpexpandq(a.as_i64x8(), src.as_i64x8(), k)) }
19407}
19408
19409#[inline]
19413#[target_feature(enable = "avx512f")]
19414#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19415#[cfg_attr(test, assert_instr(vpexpandq))]
19416pub fn _mm512_maskz_expand_epi64(k: __mmask8, a: __m512i) -> __m512i {
19417 unsafe { transmute(vpexpandq(a.as_i64x8(), i64x8::ZERO, k)) }
19418}
19419
19420#[inline]
19424#[target_feature(enable = "avx512f,avx512vl")]
19425#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19426#[cfg_attr(test, assert_instr(vpexpandq))]
19427pub fn _mm256_mask_expand_epi64(src: __m256i, k: __mmask8, a: __m256i) -> __m256i {
19428 unsafe { transmute(vpexpandq256(a.as_i64x4(), src.as_i64x4(), k)) }
19429}
19430
19431#[inline]
19435#[target_feature(enable = "avx512f,avx512vl")]
19436#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19437#[cfg_attr(test, assert_instr(vpexpandq))]
19438pub fn _mm256_maskz_expand_epi64(k: __mmask8, a: __m256i) -> __m256i {
19439 unsafe { transmute(vpexpandq256(a.as_i64x4(), i64x4::ZERO, k)) }
19440}
19441
19442#[inline]
19446#[target_feature(enable = "avx512f,avx512vl")]
19447#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19448#[cfg_attr(test, assert_instr(vpexpandq))]
19449pub fn _mm_mask_expand_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
19450 unsafe { transmute(vpexpandq128(a.as_i64x2(), src.as_i64x2(), k)) }
19451}
19452
19453#[inline]
19457#[target_feature(enable = "avx512f,avx512vl")]
19458#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19459#[cfg_attr(test, assert_instr(vpexpandq))]
19460pub fn _mm_maskz_expand_epi64(k: __mmask8, a: __m128i) -> __m128i {
19461 unsafe { transmute(vpexpandq128(a.as_i64x2(), i64x2::ZERO, k)) }
19462}
19463
19464#[inline]
19468#[target_feature(enable = "avx512f")]
19469#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19470#[cfg_attr(test, assert_instr(vexpandps))]
19471pub fn _mm512_mask_expand_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
19472 unsafe { transmute(vexpandps(a.as_f32x16(), src.as_f32x16(), k)) }
19473}
19474
19475#[inline]
19479#[target_feature(enable = "avx512f")]
19480#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19481#[cfg_attr(test, assert_instr(vexpandps))]
19482pub fn _mm512_maskz_expand_ps(k: __mmask16, a: __m512) -> __m512 {
19483 unsafe { transmute(vexpandps(a.as_f32x16(), f32x16::ZERO, k)) }
19484}
19485
19486#[inline]
19490#[target_feature(enable = "avx512f,avx512vl")]
19491#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19492#[cfg_attr(test, assert_instr(vexpandps))]
19493pub fn _mm256_mask_expand_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
19494 unsafe { transmute(vexpandps256(a.as_f32x8(), src.as_f32x8(), k)) }
19495}
19496
19497#[inline]
19501#[target_feature(enable = "avx512f,avx512vl")]
19502#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19503#[cfg_attr(test, assert_instr(vexpandps))]
19504pub fn _mm256_maskz_expand_ps(k: __mmask8, a: __m256) -> __m256 {
19505 unsafe { transmute(vexpandps256(a.as_f32x8(), f32x8::ZERO, k)) }
19506}
19507
19508#[inline]
19512#[target_feature(enable = "avx512f,avx512vl")]
19513#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19514#[cfg_attr(test, assert_instr(vexpandps))]
19515pub fn _mm_mask_expand_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
19516 unsafe { transmute(vexpandps128(a.as_f32x4(), src.as_f32x4(), k)) }
19517}
19518
19519#[inline]
19523#[target_feature(enable = "avx512f,avx512vl")]
19524#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19525#[cfg_attr(test, assert_instr(vexpandps))]
19526pub fn _mm_maskz_expand_ps(k: __mmask8, a: __m128) -> __m128 {
19527 unsafe { transmute(vexpandps128(a.as_f32x4(), f32x4::ZERO, k)) }
19528}
19529
19530#[inline]
19534#[target_feature(enable = "avx512f")]
19535#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19536#[cfg_attr(test, assert_instr(vexpandpd))]
19537pub fn _mm512_mask_expand_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
19538 unsafe { transmute(vexpandpd(a.as_f64x8(), src.as_f64x8(), k)) }
19539}
19540
19541#[inline]
19545#[target_feature(enable = "avx512f")]
19546#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19547#[cfg_attr(test, assert_instr(vexpandpd))]
19548pub fn _mm512_maskz_expand_pd(k: __mmask8, a: __m512d) -> __m512d {
19549 unsafe { transmute(vexpandpd(a.as_f64x8(), f64x8::ZERO, k)) }
19550}
19551
19552#[inline]
19556#[target_feature(enable = "avx512f,avx512vl")]
19557#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19558#[cfg_attr(test, assert_instr(vexpandpd))]
19559pub fn _mm256_mask_expand_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
19560 unsafe { transmute(vexpandpd256(a.as_f64x4(), src.as_f64x4(), k)) }
19561}
19562
19563#[inline]
19567#[target_feature(enable = "avx512f,avx512vl")]
19568#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19569#[cfg_attr(test, assert_instr(vexpandpd))]
19570pub fn _mm256_maskz_expand_pd(k: __mmask8, a: __m256d) -> __m256d {
19571 unsafe { transmute(vexpandpd256(a.as_f64x4(), f64x4::ZERO, k)) }
19572}
19573
19574#[inline]
19578#[target_feature(enable = "avx512f,avx512vl")]
19579#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19580#[cfg_attr(test, assert_instr(vexpandpd))]
19581pub fn _mm_mask_expand_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
19582 unsafe { transmute(vexpandpd128(a.as_f64x2(), src.as_f64x2(), k)) }
19583}
19584
19585#[inline]
19589#[target_feature(enable = "avx512f,avx512vl")]
19590#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19591#[cfg_attr(test, assert_instr(vexpandpd))]
19592pub fn _mm_maskz_expand_pd(k: __mmask8, a: __m128d) -> __m128d {
19593 unsafe { transmute(vexpandpd128(a.as_f64x2(), f64x2::ZERO, k)) }
19594}
19595
19596#[inline]
19600#[target_feature(enable = "avx512f")]
19601#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19602#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19603#[rustc_legacy_const_generics(1)]
19604#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19605pub const fn _mm512_rol_epi32<const IMM8: i32>(a: __m512i) -> __m512i {
19606 static_assert_uimm_bits!(IMM8, 8);
19607 _mm512_rolv_epi32(a, _mm512_set1_epi32(IMM8))
19608}
19609
19610#[inline]
19614#[target_feature(enable = "avx512f")]
19615#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19616#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19617#[rustc_legacy_const_generics(3)]
19618#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19619pub const fn _mm512_mask_rol_epi32<const IMM8: i32>(
19620 src: __m512i,
19621 k: __mmask16,
19622 a: __m512i,
19623) -> __m512i {
19624 static_assert_uimm_bits!(IMM8, 8);
19625 _mm512_mask_rolv_epi32(src, k, a, _mm512_set1_epi32(IMM8))
19626}
19627
19628#[inline]
19632#[target_feature(enable = "avx512f")]
19633#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19634#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19635#[rustc_legacy_const_generics(2)]
19636#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19637pub const fn _mm512_maskz_rol_epi32<const IMM8: i32>(k: __mmask16, a: __m512i) -> __m512i {
19638 static_assert_uimm_bits!(IMM8, 8);
19639 _mm512_maskz_rolv_epi32(k, a, _mm512_set1_epi32(IMM8))
19640}
19641
19642#[inline]
19646#[target_feature(enable = "avx512f,avx512vl")]
19647#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19648#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19649#[rustc_legacy_const_generics(1)]
19650#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19651pub const fn _mm256_rol_epi32<const IMM8: i32>(a: __m256i) -> __m256i {
19652 static_assert_uimm_bits!(IMM8, 8);
19653 _mm256_rolv_epi32(a, _mm256_set1_epi32(IMM8))
19654}
19655
19656#[inline]
19660#[target_feature(enable = "avx512f,avx512vl")]
19661#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19662#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19663#[rustc_legacy_const_generics(3)]
19664#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19665pub const fn _mm256_mask_rol_epi32<const IMM8: i32>(
19666 src: __m256i,
19667 k: __mmask8,
19668 a: __m256i,
19669) -> __m256i {
19670 static_assert_uimm_bits!(IMM8, 8);
19671 _mm256_mask_rolv_epi32(src, k, a, _mm256_set1_epi32(IMM8))
19672}
19673
19674#[inline]
19678#[target_feature(enable = "avx512f,avx512vl")]
19679#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19680#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19681#[rustc_legacy_const_generics(2)]
19682#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19683pub const fn _mm256_maskz_rol_epi32<const IMM8: i32>(k: __mmask8, a: __m256i) -> __m256i {
19684 static_assert_uimm_bits!(IMM8, 8);
19685 _mm256_maskz_rolv_epi32(k, a, _mm256_set1_epi32(IMM8))
19686}
19687
19688#[inline]
19692#[target_feature(enable = "avx512f,avx512vl")]
19693#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19694#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19695#[rustc_legacy_const_generics(1)]
19696#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19697pub const fn _mm_rol_epi32<const IMM8: i32>(a: __m128i) -> __m128i {
19698 static_assert_uimm_bits!(IMM8, 8);
19699 _mm_rolv_epi32(a, _mm_set1_epi32(IMM8))
19700}
19701
19702#[inline]
19706#[target_feature(enable = "avx512f,avx512vl")]
19707#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19708#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19709#[rustc_legacy_const_generics(3)]
19710#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19711pub const fn _mm_mask_rol_epi32<const IMM8: i32>(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
19712 static_assert_uimm_bits!(IMM8, 8);
19713 _mm_mask_rolv_epi32(src, k, a, _mm_set1_epi32(IMM8))
19714}
19715
19716#[inline]
19720#[target_feature(enable = "avx512f,avx512vl")]
19721#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19722#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19723#[rustc_legacy_const_generics(2)]
19724#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19725pub const fn _mm_maskz_rol_epi32<const IMM8: i32>(k: __mmask8, a: __m128i) -> __m128i {
19726 static_assert_uimm_bits!(IMM8, 8);
19727 _mm_maskz_rolv_epi32(k, a, _mm_set1_epi32(IMM8))
19728}
19729
19730#[inline]
19734#[target_feature(enable = "avx512f")]
19735#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19736#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19737#[rustc_legacy_const_generics(1)]
19738#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19739pub const fn _mm512_ror_epi32<const IMM8: i32>(a: __m512i) -> __m512i {
19740 static_assert_uimm_bits!(IMM8, 8);
19741 _mm512_rorv_epi32(a, _mm512_set1_epi32(IMM8))
19742}
19743
19744#[inline]
19748#[target_feature(enable = "avx512f")]
19749#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19750#[cfg_attr(test, assert_instr(vprold, IMM8 = 123))]
19751#[rustc_legacy_const_generics(3)]
19752#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19753pub const fn _mm512_mask_ror_epi32<const IMM8: i32>(
19754 src: __m512i,
19755 k: __mmask16,
19756 a: __m512i,
19757) -> __m512i {
19758 static_assert_uimm_bits!(IMM8, 8);
19759 _mm512_mask_rorv_epi32(src, k, a, _mm512_set1_epi32(IMM8))
19760}
19761
19762#[inline]
19766#[target_feature(enable = "avx512f")]
19767#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19768#[cfg_attr(test, assert_instr(vprold, IMM8 = 123))]
19769#[rustc_legacy_const_generics(2)]
19770#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19771pub const fn _mm512_maskz_ror_epi32<const IMM8: i32>(k: __mmask16, a: __m512i) -> __m512i {
19772 static_assert_uimm_bits!(IMM8, 8);
19773 _mm512_maskz_rorv_epi32(k, a, _mm512_set1_epi32(IMM8))
19774}
19775
19776#[inline]
19780#[target_feature(enable = "avx512f,avx512vl")]
19781#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19782#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19783#[rustc_legacy_const_generics(1)]
19784#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19785pub const fn _mm256_ror_epi32<const IMM8: i32>(a: __m256i) -> __m256i {
19786 static_assert_uimm_bits!(IMM8, 8);
19787 _mm256_rorv_epi32(a, _mm256_set1_epi32(IMM8))
19788}
19789
19790#[inline]
19794#[target_feature(enable = "avx512f,avx512vl")]
19795#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19796#[cfg_attr(test, assert_instr(vprold, IMM8 = 123))]
19797#[rustc_legacy_const_generics(3)]
19798#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19799pub const fn _mm256_mask_ror_epi32<const IMM8: i32>(
19800 src: __m256i,
19801 k: __mmask8,
19802 a: __m256i,
19803) -> __m256i {
19804 static_assert_uimm_bits!(IMM8, 8);
19805 _mm256_mask_rorv_epi32(src, k, a, _mm256_set1_epi32(IMM8))
19806}
19807
19808#[inline]
19812#[target_feature(enable = "avx512f,avx512vl")]
19813#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19814#[cfg_attr(test, assert_instr(vprold, IMM8 = 123))]
19815#[rustc_legacy_const_generics(2)]
19816#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19817pub const fn _mm256_maskz_ror_epi32<const IMM8: i32>(k: __mmask8, a: __m256i) -> __m256i {
19818 static_assert_uimm_bits!(IMM8, 8);
19819 _mm256_maskz_rorv_epi32(k, a, _mm256_set1_epi32(IMM8))
19820}
19821
19822#[inline]
19826#[target_feature(enable = "avx512f,avx512vl")]
19827#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19828#[cfg_attr(test, assert_instr(vprold, IMM8 = 1))]
19829#[rustc_legacy_const_generics(1)]
19830#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19831pub const fn _mm_ror_epi32<const IMM8: i32>(a: __m128i) -> __m128i {
19832 static_assert_uimm_bits!(IMM8, 8);
19833 _mm_rorv_epi32(a, _mm_set1_epi32(IMM8))
19834}
19835
19836#[inline]
19840#[target_feature(enable = "avx512f,avx512vl")]
19841#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19842#[cfg_attr(test, assert_instr(vprold, IMM8 = 123))]
19843#[rustc_legacy_const_generics(3)]
19844#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19845pub const fn _mm_mask_ror_epi32<const IMM8: i32>(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
19846 static_assert_uimm_bits!(IMM8, 8);
19847 _mm_mask_rorv_epi32(src, k, a, _mm_set1_epi32(IMM8))
19848}
19849
19850#[inline]
19854#[target_feature(enable = "avx512f,avx512vl")]
19855#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19856#[cfg_attr(test, assert_instr(vprold, IMM8 = 123))]
19857#[rustc_legacy_const_generics(2)]
19858#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19859pub const fn _mm_maskz_ror_epi32<const IMM8: i32>(k: __mmask8, a: __m128i) -> __m128i {
19860 static_assert_uimm_bits!(IMM8, 8);
19861 _mm_maskz_rorv_epi32(k, a, _mm_set1_epi32(IMM8))
19862}
19863
19864#[inline]
19868#[target_feature(enable = "avx512f")]
19869#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19870#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19871#[rustc_legacy_const_generics(1)]
19872#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19873pub const fn _mm512_rol_epi64<const IMM8: i32>(a: __m512i) -> __m512i {
19874 static_assert_uimm_bits!(IMM8, 8);
19875 _mm512_rolv_epi64(a, _mm512_set1_epi64(IMM8 as i64))
19876}
19877
19878#[inline]
19882#[target_feature(enable = "avx512f")]
19883#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19884#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19885#[rustc_legacy_const_generics(3)]
19886#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19887pub const fn _mm512_mask_rol_epi64<const IMM8: i32>(
19888 src: __m512i,
19889 k: __mmask8,
19890 a: __m512i,
19891) -> __m512i {
19892 static_assert_uimm_bits!(IMM8, 8);
19893 _mm512_mask_rolv_epi64(src, k, a, _mm512_set1_epi64(IMM8 as i64))
19894}
19895
19896#[inline]
19900#[target_feature(enable = "avx512f")]
19901#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19902#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19903#[rustc_legacy_const_generics(2)]
19904#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19905pub const fn _mm512_maskz_rol_epi64<const IMM8: i32>(k: __mmask8, a: __m512i) -> __m512i {
19906 static_assert_uimm_bits!(IMM8, 8);
19907 _mm512_maskz_rolv_epi64(k, a, _mm512_set1_epi64(IMM8 as i64))
19908}
19909
19910#[inline]
19914#[target_feature(enable = "avx512f,avx512vl")]
19915#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19916#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19917#[rustc_legacy_const_generics(1)]
19918#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19919pub const fn _mm256_rol_epi64<const IMM8: i32>(a: __m256i) -> __m256i {
19920 static_assert_uimm_bits!(IMM8, 8);
19921 _mm256_rolv_epi64(a, _mm256_set1_epi64x(IMM8 as i64))
19922}
19923
19924#[inline]
19928#[target_feature(enable = "avx512f,avx512vl")]
19929#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19930#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19931#[rustc_legacy_const_generics(3)]
19932#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19933pub const fn _mm256_mask_rol_epi64<const IMM8: i32>(
19934 src: __m256i,
19935 k: __mmask8,
19936 a: __m256i,
19937) -> __m256i {
19938 static_assert_uimm_bits!(IMM8, 8);
19939 _mm256_mask_rolv_epi64(src, k, a, _mm256_set1_epi64x(IMM8 as i64))
19940}
19941
19942#[inline]
19946#[target_feature(enable = "avx512f,avx512vl")]
19947#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19948#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19949#[rustc_legacy_const_generics(2)]
19950#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19951pub const fn _mm256_maskz_rol_epi64<const IMM8: i32>(k: __mmask8, a: __m256i) -> __m256i {
19952 static_assert_uimm_bits!(IMM8, 8);
19953 _mm256_maskz_rolv_epi64(k, a, _mm256_set1_epi64x(IMM8 as i64))
19954}
19955
19956#[inline]
19960#[target_feature(enable = "avx512f,avx512vl")]
19961#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19962#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19963#[rustc_legacy_const_generics(1)]
19964#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19965pub const fn _mm_rol_epi64<const IMM8: i32>(a: __m128i) -> __m128i {
19966 static_assert_uimm_bits!(IMM8, 8);
19967 _mm_rolv_epi64(a, _mm_set1_epi64x(IMM8 as i64))
19968}
19969
19970#[inline]
19974#[target_feature(enable = "avx512f,avx512vl")]
19975#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19976#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19977#[rustc_legacy_const_generics(3)]
19978#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19979pub const fn _mm_mask_rol_epi64<const IMM8: i32>(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
19980 static_assert_uimm_bits!(IMM8, 8);
19981 _mm_mask_rolv_epi64(src, k, a, _mm_set1_epi64x(IMM8 as i64))
19982}
19983
19984#[inline]
19988#[target_feature(enable = "avx512f,avx512vl")]
19989#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
19990#[cfg_attr(test, assert_instr(vprolq, IMM8 = 1))]
19991#[rustc_legacy_const_generics(2)]
19992#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
19993pub const fn _mm_maskz_rol_epi64<const IMM8: i32>(k: __mmask8, a: __m128i) -> __m128i {
19994 static_assert_uimm_bits!(IMM8, 8);
19995 _mm_maskz_rolv_epi64(k, a, _mm_set1_epi64x(IMM8 as i64))
19996}
19997
19998#[inline]
20002#[target_feature(enable = "avx512f")]
20003#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20004#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20005#[rustc_legacy_const_generics(1)]
20006#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20007pub const fn _mm512_ror_epi64<const IMM8: i32>(a: __m512i) -> __m512i {
20008 static_assert_uimm_bits!(IMM8, 8);
20009 _mm512_rorv_epi64(a, _mm512_set1_epi64(IMM8 as i64))
20010}
20011
20012#[inline]
20016#[target_feature(enable = "avx512f")]
20017#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20018#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20019#[rustc_legacy_const_generics(3)]
20020#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20021pub const fn _mm512_mask_ror_epi64<const IMM8: i32>(
20022 src: __m512i,
20023 k: __mmask8,
20024 a: __m512i,
20025) -> __m512i {
20026 static_assert_uimm_bits!(IMM8, 8);
20027 _mm512_mask_rorv_epi64(src, k, a, _mm512_set1_epi64(IMM8 as i64))
20028}
20029
20030#[inline]
20034#[target_feature(enable = "avx512f")]
20035#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20036#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20037#[rustc_legacy_const_generics(2)]
20038#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20039pub const fn _mm512_maskz_ror_epi64<const IMM8: i32>(k: __mmask8, a: __m512i) -> __m512i {
20040 static_assert_uimm_bits!(IMM8, 8);
20041 _mm512_maskz_rorv_epi64(k, a, _mm512_set1_epi64(IMM8 as i64))
20042}
20043
20044#[inline]
20048#[target_feature(enable = "avx512f,avx512vl")]
20049#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20050#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20051#[rustc_legacy_const_generics(1)]
20052#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20053pub const fn _mm256_ror_epi64<const IMM8: i32>(a: __m256i) -> __m256i {
20054 static_assert_uimm_bits!(IMM8, 8);
20055 _mm256_rorv_epi64(a, _mm256_set1_epi64x(IMM8 as i64))
20056}
20057
20058#[inline]
20062#[target_feature(enable = "avx512f,avx512vl")]
20063#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20064#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20065#[rustc_legacy_const_generics(3)]
20066#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20067pub const fn _mm256_mask_ror_epi64<const IMM8: i32>(
20068 src: __m256i,
20069 k: __mmask8,
20070 a: __m256i,
20071) -> __m256i {
20072 static_assert_uimm_bits!(IMM8, 8);
20073 _mm256_mask_rorv_epi64(src, k, a, _mm256_set1_epi64x(IMM8 as i64))
20074}
20075
20076#[inline]
20080#[target_feature(enable = "avx512f,avx512vl")]
20081#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20082#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20083#[rustc_legacy_const_generics(2)]
20084#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20085pub const fn _mm256_maskz_ror_epi64<const IMM8: i32>(k: __mmask8, a: __m256i) -> __m256i {
20086 static_assert_uimm_bits!(IMM8, 8);
20087 _mm256_maskz_rorv_epi64(k, a, _mm256_set1_epi64x(IMM8 as i64))
20088}
20089
20090#[inline]
20094#[target_feature(enable = "avx512f,avx512vl")]
20095#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20096#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20097#[rustc_legacy_const_generics(1)]
20098#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20099pub const fn _mm_ror_epi64<const IMM8: i32>(a: __m128i) -> __m128i {
20100 static_assert_uimm_bits!(IMM8, 8);
20101 _mm_rorv_epi64(a, _mm_set1_epi64x(IMM8 as i64))
20102}
20103
20104#[inline]
20108#[target_feature(enable = "avx512f,avx512vl")]
20109#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20110#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20111#[rustc_legacy_const_generics(3)]
20112#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20113pub const fn _mm_mask_ror_epi64<const IMM8: i32>(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
20114 static_assert_uimm_bits!(IMM8, 8);
20115 _mm_mask_rorv_epi64(src, k, a, _mm_set1_epi64x(IMM8 as i64))
20116}
20117
20118#[inline]
20122#[target_feature(enable = "avx512f,avx512vl")]
20123#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20124#[cfg_attr(test, assert_instr(vprolq, IMM8 = 15))]
20125#[rustc_legacy_const_generics(2)]
20126#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20127pub const fn _mm_maskz_ror_epi64<const IMM8: i32>(k: __mmask8, a: __m128i) -> __m128i {
20128 static_assert_uimm_bits!(IMM8, 8);
20129 _mm_maskz_rorv_epi64(k, a, _mm_set1_epi64x(IMM8 as i64))
20130}
20131
20132#[inline]
20136#[target_feature(enable = "avx512f")]
20137#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20138#[cfg_attr(test, assert_instr(vpslld, IMM8 = 5))]
20139#[rustc_legacy_const_generics(1)]
20140#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20141pub const fn _mm512_slli_epi32<const IMM8: u32>(a: __m512i) -> __m512i {
20142 unsafe {
20143 static_assert_uimm_bits!(IMM8, 8);
20144 if IMM8 >= 32 {
20145 _mm512_setzero_si512()
20146 } else {
20147 transmute(simd_shl(a.as_u32x16(), u32x16::splat(IMM8)))
20148 }
20149 }
20150}
20151
20152#[inline]
20156#[target_feature(enable = "avx512f")]
20157#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20158#[cfg_attr(test, assert_instr(vpslld, IMM8 = 5))]
20159#[rustc_legacy_const_generics(3)]
20160#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20161pub const fn _mm512_mask_slli_epi32<const IMM8: u32>(
20162 src: __m512i,
20163 k: __mmask16,
20164 a: __m512i,
20165) -> __m512i {
20166 unsafe {
20167 static_assert_uimm_bits!(IMM8, 8);
20168 let shf = if IMM8 >= 32 {
20169 u32x16::ZERO
20170 } else {
20171 simd_shl(a.as_u32x16(), u32x16::splat(IMM8))
20172 };
20173 transmute(simd_select_bitmask(k, shf, src.as_u32x16()))
20174 }
20175}
20176
20177#[inline]
20181#[target_feature(enable = "avx512f")]
20182#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20183#[cfg_attr(test, assert_instr(vpslld, IMM8 = 5))]
20184#[rustc_legacy_const_generics(2)]
20185#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20186pub const fn _mm512_maskz_slli_epi32<const IMM8: u32>(k: __mmask16, a: __m512i) -> __m512i {
20187 unsafe {
20188 static_assert_uimm_bits!(IMM8, 8);
20189 if IMM8 >= 32 {
20190 _mm512_setzero_si512()
20191 } else {
20192 let shf = simd_shl(a.as_u32x16(), u32x16::splat(IMM8));
20193 transmute(simd_select_bitmask(k, shf, u32x16::ZERO))
20194 }
20195 }
20196}
20197
20198#[inline]
20202#[target_feature(enable = "avx512f,avx512vl")]
20203#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20204#[cfg_attr(test, assert_instr(vpslld, IMM8 = 5))]
20205#[rustc_legacy_const_generics(3)]
20206#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20207pub const fn _mm256_mask_slli_epi32<const IMM8: u32>(
20208 src: __m256i,
20209 k: __mmask8,
20210 a: __m256i,
20211) -> __m256i {
20212 unsafe {
20213 static_assert_uimm_bits!(IMM8, 8);
20214 let r = if IMM8 >= 32 {
20215 u32x8::ZERO
20216 } else {
20217 simd_shl(a.as_u32x8(), u32x8::splat(IMM8))
20218 };
20219 transmute(simd_select_bitmask(k, r, src.as_u32x8()))
20220 }
20221}
20222
20223#[inline]
20227#[target_feature(enable = "avx512f,avx512vl")]
20228#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20229#[cfg_attr(test, assert_instr(vpslld, IMM8 = 5))]
20230#[rustc_legacy_const_generics(2)]
20231#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20232pub const fn _mm256_maskz_slli_epi32<const IMM8: u32>(k: __mmask8, a: __m256i) -> __m256i {
20233 unsafe {
20234 static_assert_uimm_bits!(IMM8, 8);
20235 if IMM8 >= 32 {
20236 _mm256_setzero_si256()
20237 } else {
20238 let r = simd_shl(a.as_u32x8(), u32x8::splat(IMM8));
20239 transmute(simd_select_bitmask(k, r, u32x8::ZERO))
20240 }
20241 }
20242}
20243
20244#[inline]
20248#[target_feature(enable = "avx512f,avx512vl")]
20249#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20250#[cfg_attr(test, assert_instr(vpslld, IMM8 = 5))]
20251#[rustc_legacy_const_generics(3)]
20252#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20253pub const fn _mm_mask_slli_epi32<const IMM8: u32>(
20254 src: __m128i,
20255 k: __mmask8,
20256 a: __m128i,
20257) -> __m128i {
20258 unsafe {
20259 static_assert_uimm_bits!(IMM8, 8);
20260 let r = if IMM8 >= 32 {
20261 u32x4::ZERO
20262 } else {
20263 simd_shl(a.as_u32x4(), u32x4::splat(IMM8))
20264 };
20265 transmute(simd_select_bitmask(k, r, src.as_u32x4()))
20266 }
20267}
20268
20269#[inline]
20273#[target_feature(enable = "avx512f,avx512vl")]
20274#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20275#[cfg_attr(test, assert_instr(vpslld, IMM8 = 5))]
20276#[rustc_legacy_const_generics(2)]
20277#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20278pub const fn _mm_maskz_slli_epi32<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
20279 unsafe {
20280 static_assert_uimm_bits!(IMM8, 8);
20281 if IMM8 >= 32 {
20282 _mm_setzero_si128()
20283 } else {
20284 let r = simd_shl(a.as_u32x4(), u32x4::splat(IMM8));
20285 transmute(simd_select_bitmask(k, r, u32x4::ZERO))
20286 }
20287 }
20288}
20289
20290#[inline]
20294#[target_feature(enable = "avx512f")]
20295#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20296#[cfg_attr(test, assert_instr(vpsrld, IMM8 = 1))]
20297#[rustc_legacy_const_generics(1)]
20298#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20299pub const fn _mm512_srli_epi32<const IMM8: u32>(a: __m512i) -> __m512i {
20300 unsafe {
20301 static_assert_uimm_bits!(IMM8, 8);
20302 if IMM8 >= 32 {
20303 _mm512_setzero_si512()
20304 } else {
20305 transmute(simd_shr(a.as_u32x16(), u32x16::splat(IMM8)))
20306 }
20307 }
20308}
20309
20310#[inline]
20314#[target_feature(enable = "avx512f")]
20315#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20316#[cfg_attr(test, assert_instr(vpsrld, IMM8 = 1))]
20317#[rustc_legacy_const_generics(3)]
20318#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20319pub const fn _mm512_mask_srli_epi32<const IMM8: u32>(
20320 src: __m512i,
20321 k: __mmask16,
20322 a: __m512i,
20323) -> __m512i {
20324 unsafe {
20325 static_assert_uimm_bits!(IMM8, 8);
20326 let shf = if IMM8 >= 32 {
20327 u32x16::ZERO
20328 } else {
20329 simd_shr(a.as_u32x16(), u32x16::splat(IMM8))
20330 };
20331 transmute(simd_select_bitmask(k, shf, src.as_u32x16()))
20332 }
20333}
20334
20335#[inline]
20339#[target_feature(enable = "avx512f")]
20340#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20341#[cfg_attr(test, assert_instr(vpsrld, IMM8 = 1))]
20342#[rustc_legacy_const_generics(2)]
20343#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20344pub const fn _mm512_maskz_srli_epi32<const IMM8: u32>(k: __mmask16, a: __m512i) -> __m512i {
20345 unsafe {
20346 static_assert_uimm_bits!(IMM8, 8);
20347 if IMM8 >= 32 {
20348 _mm512_setzero_si512()
20349 } else {
20350 let shf = simd_shr(a.as_u32x16(), u32x16::splat(IMM8));
20351 transmute(simd_select_bitmask(k, shf, u32x16::ZERO))
20352 }
20353 }
20354}
20355
20356#[inline]
20360#[target_feature(enable = "avx512f,avx512vl")]
20361#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20362#[cfg_attr(test, assert_instr(vpsrld, IMM8 = 1))]
20363#[rustc_legacy_const_generics(3)]
20364#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20365pub const fn _mm256_mask_srli_epi32<const IMM8: u32>(
20366 src: __m256i,
20367 k: __mmask8,
20368 a: __m256i,
20369) -> __m256i {
20370 unsafe {
20371 static_assert_uimm_bits!(IMM8, 8);
20372 let r = if IMM8 >= 32 {
20373 u32x8::ZERO
20374 } else {
20375 simd_shr(a.as_u32x8(), u32x8::splat(IMM8))
20376 };
20377 transmute(simd_select_bitmask(k, r, src.as_u32x8()))
20378 }
20379}
20380
20381#[inline]
20385#[target_feature(enable = "avx512f,avx512vl")]
20386#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20387#[cfg_attr(test, assert_instr(vpsrld, IMM8 = 1))]
20388#[rustc_legacy_const_generics(2)]
20389#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20390pub const fn _mm256_maskz_srli_epi32<const IMM8: u32>(k: __mmask8, a: __m256i) -> __m256i {
20391 unsafe {
20392 static_assert_uimm_bits!(IMM8, 8);
20393 if IMM8 >= 32 {
20394 _mm256_setzero_si256()
20395 } else {
20396 let r = simd_shr(a.as_u32x8(), u32x8::splat(IMM8));
20397 transmute(simd_select_bitmask(k, r, u32x8::ZERO))
20398 }
20399 }
20400}
20401
20402#[inline]
20406#[target_feature(enable = "avx512f,avx512vl")]
20407#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20408#[cfg_attr(test, assert_instr(vpsrld, IMM8 = 1))]
20409#[rustc_legacy_const_generics(3)]
20410#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20411pub const fn _mm_mask_srli_epi32<const IMM8: u32>(
20412 src: __m128i,
20413 k: __mmask8,
20414 a: __m128i,
20415) -> __m128i {
20416 unsafe {
20417 static_assert_uimm_bits!(IMM8, 8);
20418 let r = if IMM8 >= 32 {
20419 u32x4::ZERO
20420 } else {
20421 simd_shr(a.as_u32x4(), u32x4::splat(IMM8))
20422 };
20423 transmute(simd_select_bitmask(k, r, src.as_u32x4()))
20424 }
20425}
20426
20427#[inline]
20431#[target_feature(enable = "avx512f,avx512vl")]
20432#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20433#[cfg_attr(test, assert_instr(vpsrld, IMM8 = 1))]
20434#[rustc_legacy_const_generics(2)]
20435#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20436pub const fn _mm_maskz_srli_epi32<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
20437 unsafe {
20438 static_assert_uimm_bits!(IMM8, 8);
20439 if IMM8 >= 32 {
20440 _mm_setzero_si128()
20441 } else {
20442 let r = simd_shr(a.as_u32x4(), u32x4::splat(IMM8));
20443 transmute(simd_select_bitmask(k, r, u32x4::ZERO))
20444 }
20445 }
20446}
20447
20448#[inline]
20452#[target_feature(enable = "avx512f")]
20453#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20454#[cfg_attr(test, assert_instr(vpsllq, IMM8 = 5))]
20455#[rustc_legacy_const_generics(1)]
20456#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20457pub const fn _mm512_slli_epi64<const IMM8: u32>(a: __m512i) -> __m512i {
20458 unsafe {
20459 static_assert_uimm_bits!(IMM8, 8);
20460 if IMM8 >= 64 {
20461 _mm512_setzero_si512()
20462 } else {
20463 transmute(simd_shl(a.as_u64x8(), u64x8::splat(IMM8 as u64)))
20464 }
20465 }
20466}
20467
20468#[inline]
20472#[target_feature(enable = "avx512f")]
20473#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20474#[cfg_attr(test, assert_instr(vpsllq, IMM8 = 5))]
20475#[rustc_legacy_const_generics(3)]
20476#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20477pub const fn _mm512_mask_slli_epi64<const IMM8: u32>(
20478 src: __m512i,
20479 k: __mmask8,
20480 a: __m512i,
20481) -> __m512i {
20482 unsafe {
20483 static_assert_uimm_bits!(IMM8, 8);
20484 let shf = if IMM8 >= 64 {
20485 u64x8::ZERO
20486 } else {
20487 simd_shl(a.as_u64x8(), u64x8::splat(IMM8 as u64))
20488 };
20489 transmute(simd_select_bitmask(k, shf, src.as_u64x8()))
20490 }
20491}
20492
20493#[inline]
20497#[target_feature(enable = "avx512f")]
20498#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20499#[cfg_attr(test, assert_instr(vpsllq, IMM8 = 5))]
20500#[rustc_legacy_const_generics(2)]
20501#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20502pub const fn _mm512_maskz_slli_epi64<const IMM8: u32>(k: __mmask8, a: __m512i) -> __m512i {
20503 unsafe {
20504 static_assert_uimm_bits!(IMM8, 8);
20505 if IMM8 >= 64 {
20506 _mm512_setzero_si512()
20507 } else {
20508 let shf = simd_shl(a.as_u64x8(), u64x8::splat(IMM8 as u64));
20509 transmute(simd_select_bitmask(k, shf, u64x8::ZERO))
20510 }
20511 }
20512}
20513
20514#[inline]
20518#[target_feature(enable = "avx512f,avx512vl")]
20519#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20520#[cfg_attr(test, assert_instr(vpsllq, IMM8 = 5))]
20521#[rustc_legacy_const_generics(3)]
20522#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20523pub const fn _mm256_mask_slli_epi64<const IMM8: u32>(
20524 src: __m256i,
20525 k: __mmask8,
20526 a: __m256i,
20527) -> __m256i {
20528 unsafe {
20529 static_assert_uimm_bits!(IMM8, 8);
20530 let r = if IMM8 >= 64 {
20531 u64x4::ZERO
20532 } else {
20533 simd_shl(a.as_u64x4(), u64x4::splat(IMM8 as u64))
20534 };
20535 transmute(simd_select_bitmask(k, r, src.as_u64x4()))
20536 }
20537}
20538
20539#[inline]
20543#[target_feature(enable = "avx512f,avx512vl")]
20544#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20545#[cfg_attr(test, assert_instr(vpsllq, IMM8 = 5))]
20546#[rustc_legacy_const_generics(2)]
20547#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20548pub const fn _mm256_maskz_slli_epi64<const IMM8: u32>(k: __mmask8, a: __m256i) -> __m256i {
20549 unsafe {
20550 static_assert_uimm_bits!(IMM8, 8);
20551 if IMM8 >= 64 {
20552 _mm256_setzero_si256()
20553 } else {
20554 let r = simd_shl(a.as_u64x4(), u64x4::splat(IMM8 as u64));
20555 transmute(simd_select_bitmask(k, r, u64x4::ZERO))
20556 }
20557 }
20558}
20559
20560#[inline]
20564#[target_feature(enable = "avx512f,avx512vl")]
20565#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20566#[cfg_attr(test, assert_instr(vpsllq, IMM8 = 5))]
20567#[rustc_legacy_const_generics(3)]
20568#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20569pub const fn _mm_mask_slli_epi64<const IMM8: u32>(
20570 src: __m128i,
20571 k: __mmask8,
20572 a: __m128i,
20573) -> __m128i {
20574 unsafe {
20575 static_assert_uimm_bits!(IMM8, 8);
20576 let r = if IMM8 >= 64 {
20577 u64x2::ZERO
20578 } else {
20579 simd_shl(a.as_u64x2(), u64x2::splat(IMM8 as u64))
20580 };
20581 transmute(simd_select_bitmask(k, r, src.as_u64x2()))
20582 }
20583}
20584
20585#[inline]
20589#[target_feature(enable = "avx512f,avx512vl")]
20590#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20591#[cfg_attr(test, assert_instr(vpsllq, IMM8 = 5))]
20592#[rustc_legacy_const_generics(2)]
20593#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20594pub const fn _mm_maskz_slli_epi64<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
20595 unsafe {
20596 static_assert_uimm_bits!(IMM8, 8);
20597 if IMM8 >= 64 {
20598 _mm_setzero_si128()
20599 } else {
20600 let r = simd_shl(a.as_u64x2(), u64x2::splat(IMM8 as u64));
20601 transmute(simd_select_bitmask(k, r, u64x2::ZERO))
20602 }
20603 }
20604}
20605
20606#[inline]
20610#[target_feature(enable = "avx512f")]
20611#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20612#[cfg_attr(test, assert_instr(vpsrlq, IMM8 = 1))]
20613#[rustc_legacy_const_generics(1)]
20614#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20615pub const fn _mm512_srli_epi64<const IMM8: u32>(a: __m512i) -> __m512i {
20616 unsafe {
20617 static_assert_uimm_bits!(IMM8, 8);
20618 if IMM8 >= 64 {
20619 _mm512_setzero_si512()
20620 } else {
20621 transmute(simd_shr(a.as_u64x8(), u64x8::splat(IMM8 as u64)))
20622 }
20623 }
20624}
20625
20626#[inline]
20630#[target_feature(enable = "avx512f")]
20631#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20632#[cfg_attr(test, assert_instr(vpsrlq, IMM8 = 1))]
20633#[rustc_legacy_const_generics(3)]
20634#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20635pub const fn _mm512_mask_srli_epi64<const IMM8: u32>(
20636 src: __m512i,
20637 k: __mmask8,
20638 a: __m512i,
20639) -> __m512i {
20640 unsafe {
20641 static_assert_uimm_bits!(IMM8, 8);
20642 let shf = if IMM8 >= 64 {
20643 u64x8::ZERO
20644 } else {
20645 simd_shr(a.as_u64x8(), u64x8::splat(IMM8 as u64))
20646 };
20647 transmute(simd_select_bitmask(k, shf, src.as_u64x8()))
20648 }
20649}
20650
20651#[inline]
20655#[target_feature(enable = "avx512f")]
20656#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20657#[cfg_attr(test, assert_instr(vpsrlq, IMM8 = 1))]
20658#[rustc_legacy_const_generics(2)]
20659#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20660pub const fn _mm512_maskz_srli_epi64<const IMM8: u32>(k: __mmask8, a: __m512i) -> __m512i {
20661 unsafe {
20662 static_assert_uimm_bits!(IMM8, 8);
20663 if IMM8 >= 64 {
20664 _mm512_setzero_si512()
20665 } else {
20666 let shf = simd_shr(a.as_u64x8(), u64x8::splat(IMM8 as u64));
20667 transmute(simd_select_bitmask(k, shf, u64x8::ZERO))
20668 }
20669 }
20670}
20671
20672#[inline]
20676#[target_feature(enable = "avx512f,avx512vl")]
20677#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20678#[cfg_attr(test, assert_instr(vpsrlq, IMM8 = 1))]
20679#[rustc_legacy_const_generics(3)]
20680#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20681pub const fn _mm256_mask_srli_epi64<const IMM8: u32>(
20682 src: __m256i,
20683 k: __mmask8,
20684 a: __m256i,
20685) -> __m256i {
20686 unsafe {
20687 static_assert_uimm_bits!(IMM8, 8);
20688 let r = if IMM8 >= 64 {
20689 u64x4::ZERO
20690 } else {
20691 simd_shr(a.as_u64x4(), u64x4::splat(IMM8 as u64))
20692 };
20693 transmute(simd_select_bitmask(k, r, src.as_u64x4()))
20694 }
20695}
20696
20697#[inline]
20701#[target_feature(enable = "avx512f,avx512vl")]
20702#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20703#[cfg_attr(test, assert_instr(vpsrlq, IMM8 = 1))]
20704#[rustc_legacy_const_generics(2)]
20705#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20706pub const fn _mm256_maskz_srli_epi64<const IMM8: u32>(k: __mmask8, a: __m256i) -> __m256i {
20707 unsafe {
20708 static_assert_uimm_bits!(IMM8, 8);
20709 if IMM8 >= 64 {
20710 _mm256_setzero_si256()
20711 } else {
20712 let r = simd_shr(a.as_u64x4(), u64x4::splat(IMM8 as u64));
20713 transmute(simd_select_bitmask(k, r, u64x4::ZERO))
20714 }
20715 }
20716}
20717
20718#[inline]
20722#[target_feature(enable = "avx512f,avx512vl")]
20723#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20724#[cfg_attr(test, assert_instr(vpsrlq, IMM8 = 1))]
20725#[rustc_legacy_const_generics(3)]
20726#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20727pub const fn _mm_mask_srli_epi64<const IMM8: u32>(
20728 src: __m128i,
20729 k: __mmask8,
20730 a: __m128i,
20731) -> __m128i {
20732 unsafe {
20733 static_assert_uimm_bits!(IMM8, 8);
20734 let r = if IMM8 >= 64 {
20735 u64x2::ZERO
20736 } else {
20737 simd_shr(a.as_u64x2(), u64x2::splat(IMM8 as u64))
20738 };
20739 transmute(simd_select_bitmask(k, r, src.as_u64x2()))
20740 }
20741}
20742
20743#[inline]
20747#[target_feature(enable = "avx512f,avx512vl")]
20748#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20749#[cfg_attr(test, assert_instr(vpsrlq, IMM8 = 1))]
20750#[rustc_legacy_const_generics(2)]
20751#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
20752pub const fn _mm_maskz_srli_epi64<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
20753 unsafe {
20754 static_assert_uimm_bits!(IMM8, 8);
20755 if IMM8 >= 64 {
20756 _mm_setzero_si128()
20757 } else {
20758 let r = simd_shr(a.as_u64x2(), u64x2::splat(IMM8 as u64));
20759 transmute(simd_select_bitmask(k, r, u64x2::ZERO))
20760 }
20761 }
20762}
20763
20764#[inline]
20768#[target_feature(enable = "avx512f")]
20769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20770#[cfg_attr(test, assert_instr(vpslld))]
20771pub fn _mm512_sll_epi32(a: __m512i, count: __m128i) -> __m512i {
20772 unsafe { transmute(vpslld(a.as_i32x16(), count.as_i32x4())) }
20773}
20774
20775#[inline]
20779#[target_feature(enable = "avx512f")]
20780#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20781#[cfg_attr(test, assert_instr(vpslld))]
20782pub fn _mm512_mask_sll_epi32(src: __m512i, k: __mmask16, a: __m512i, count: __m128i) -> __m512i {
20783 unsafe {
20784 let shf = _mm512_sll_epi32(a, count).as_i32x16();
20785 transmute(simd_select_bitmask(k, shf, src.as_i32x16()))
20786 }
20787}
20788
20789#[inline]
20793#[target_feature(enable = "avx512f")]
20794#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20795#[cfg_attr(test, assert_instr(vpslld))]
20796pub fn _mm512_maskz_sll_epi32(k: __mmask16, a: __m512i, count: __m128i) -> __m512i {
20797 unsafe {
20798 let shf = _mm512_sll_epi32(a, count).as_i32x16();
20799 transmute(simd_select_bitmask(k, shf, i32x16::ZERO))
20800 }
20801}
20802
20803#[inline]
20807#[target_feature(enable = "avx512f,avx512vl")]
20808#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20809#[cfg_attr(test, assert_instr(vpslld))]
20810pub fn _mm256_mask_sll_epi32(src: __m256i, k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
20811 unsafe {
20812 let shf = _mm256_sll_epi32(a, count).as_i32x8();
20813 transmute(simd_select_bitmask(k, shf, src.as_i32x8()))
20814 }
20815}
20816
20817#[inline]
20821#[target_feature(enable = "avx512f,avx512vl")]
20822#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20823#[cfg_attr(test, assert_instr(vpslld))]
20824pub fn _mm256_maskz_sll_epi32(k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
20825 unsafe {
20826 let shf = _mm256_sll_epi32(a, count).as_i32x8();
20827 transmute(simd_select_bitmask(k, shf, i32x8::ZERO))
20828 }
20829}
20830
20831#[inline]
20835#[target_feature(enable = "avx512f,avx512vl")]
20836#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20837#[cfg_attr(test, assert_instr(vpslld))]
20838pub fn _mm_mask_sll_epi32(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
20839 unsafe {
20840 let shf = _mm_sll_epi32(a, count).as_i32x4();
20841 transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
20842 }
20843}
20844
20845#[inline]
20849#[target_feature(enable = "avx512f,avx512vl")]
20850#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20851#[cfg_attr(test, assert_instr(vpslld))]
20852pub fn _mm_maskz_sll_epi32(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
20853 unsafe {
20854 let shf = _mm_sll_epi32(a, count).as_i32x4();
20855 transmute(simd_select_bitmask(k, shf, i32x4::ZERO))
20856 }
20857}
20858
20859#[inline]
20863#[target_feature(enable = "avx512f")]
20864#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20865#[cfg_attr(test, assert_instr(vpsrld))]
20866pub fn _mm512_srl_epi32(a: __m512i, count: __m128i) -> __m512i {
20867 unsafe { transmute(vpsrld(a.as_i32x16(), count.as_i32x4())) }
20868}
20869
20870#[inline]
20874#[target_feature(enable = "avx512f")]
20875#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20876#[cfg_attr(test, assert_instr(vpsrld))]
20877pub fn _mm512_mask_srl_epi32(src: __m512i, k: __mmask16, a: __m512i, count: __m128i) -> __m512i {
20878 unsafe {
20879 let shf = _mm512_srl_epi32(a, count).as_i32x16();
20880 transmute(simd_select_bitmask(k, shf, src.as_i32x16()))
20881 }
20882}
20883
20884#[inline]
20888#[target_feature(enable = "avx512f")]
20889#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20890#[cfg_attr(test, assert_instr(vpsrld))]
20891pub fn _mm512_maskz_srl_epi32(k: __mmask16, a: __m512i, count: __m128i) -> __m512i {
20892 unsafe {
20893 let shf = _mm512_srl_epi32(a, count).as_i32x16();
20894 transmute(simd_select_bitmask(k, shf, i32x16::ZERO))
20895 }
20896}
20897
20898#[inline]
20902#[target_feature(enable = "avx512f,avx512vl")]
20903#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20904#[cfg_attr(test, assert_instr(vpsrld))]
20905pub fn _mm256_mask_srl_epi32(src: __m256i, k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
20906 unsafe {
20907 let shf = _mm256_srl_epi32(a, count).as_i32x8();
20908 transmute(simd_select_bitmask(k, shf, src.as_i32x8()))
20909 }
20910}
20911
20912#[inline]
20916#[target_feature(enable = "avx512f,avx512vl")]
20917#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20918#[cfg_attr(test, assert_instr(vpsrld))]
20919pub fn _mm256_maskz_srl_epi32(k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
20920 unsafe {
20921 let shf = _mm256_srl_epi32(a, count).as_i32x8();
20922 transmute(simd_select_bitmask(k, shf, i32x8::ZERO))
20923 }
20924}
20925
20926#[inline]
20930#[target_feature(enable = "avx512f,avx512vl")]
20931#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20932#[cfg_attr(test, assert_instr(vpsrld))]
20933pub fn _mm_mask_srl_epi32(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
20934 unsafe {
20935 let shf = _mm_srl_epi32(a, count).as_i32x4();
20936 transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
20937 }
20938}
20939
20940#[inline]
20944#[target_feature(enable = "avx512f,avx512vl")]
20945#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20946#[cfg_attr(test, assert_instr(vpsrld))]
20947pub fn _mm_maskz_srl_epi32(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
20948 unsafe {
20949 let shf = _mm_srl_epi32(a, count).as_i32x4();
20950 transmute(simd_select_bitmask(k, shf, i32x4::ZERO))
20951 }
20952}
20953
20954#[inline]
20958#[target_feature(enable = "avx512f")]
20959#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20960#[cfg_attr(test, assert_instr(vpsllq))]
20961pub fn _mm512_sll_epi64(a: __m512i, count: __m128i) -> __m512i {
20962 unsafe { transmute(vpsllq(a.as_i64x8(), count.as_i64x2())) }
20963}
20964
20965#[inline]
20969#[target_feature(enable = "avx512f")]
20970#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20971#[cfg_attr(test, assert_instr(vpsllq))]
20972pub fn _mm512_mask_sll_epi64(src: __m512i, k: __mmask8, a: __m512i, count: __m128i) -> __m512i {
20973 unsafe {
20974 let shf = _mm512_sll_epi64(a, count).as_i64x8();
20975 transmute(simd_select_bitmask(k, shf, src.as_i64x8()))
20976 }
20977}
20978
20979#[inline]
20983#[target_feature(enable = "avx512f")]
20984#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20985#[cfg_attr(test, assert_instr(vpsllq))]
20986pub fn _mm512_maskz_sll_epi64(k: __mmask8, a: __m512i, count: __m128i) -> __m512i {
20987 unsafe {
20988 let shf = _mm512_sll_epi64(a, count).as_i64x8();
20989 transmute(simd_select_bitmask(k, shf, i64x8::ZERO))
20990 }
20991}
20992
20993#[inline]
20997#[target_feature(enable = "avx512f,avx512vl")]
20998#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
20999#[cfg_attr(test, assert_instr(vpsllq))]
21000pub fn _mm256_mask_sll_epi64(src: __m256i, k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21001 unsafe {
21002 let shf = _mm256_sll_epi64(a, count).as_i64x4();
21003 transmute(simd_select_bitmask(k, shf, src.as_i64x4()))
21004 }
21005}
21006
21007#[inline]
21011#[target_feature(enable = "avx512f,avx512vl")]
21012#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21013#[cfg_attr(test, assert_instr(vpsllq))]
21014pub fn _mm256_maskz_sll_epi64(k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21015 unsafe {
21016 let shf = _mm256_sll_epi64(a, count).as_i64x4();
21017 transmute(simd_select_bitmask(k, shf, i64x4::ZERO))
21018 }
21019}
21020
21021#[inline]
21025#[target_feature(enable = "avx512f,avx512vl")]
21026#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21027#[cfg_attr(test, assert_instr(vpsllq))]
21028pub fn _mm_mask_sll_epi64(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21029 unsafe {
21030 let shf = _mm_sll_epi64(a, count).as_i64x2();
21031 transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
21032 }
21033}
21034
21035#[inline]
21039#[target_feature(enable = "avx512f,avx512vl")]
21040#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21041#[cfg_attr(test, assert_instr(vpsllq))]
21042pub fn _mm_maskz_sll_epi64(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21043 unsafe {
21044 let shf = _mm_sll_epi64(a, count).as_i64x2();
21045 transmute(simd_select_bitmask(k, shf, i64x2::ZERO))
21046 }
21047}
21048
21049#[inline]
21053#[target_feature(enable = "avx512f")]
21054#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21055#[cfg_attr(test, assert_instr(vpsrlq))]
21056pub fn _mm512_srl_epi64(a: __m512i, count: __m128i) -> __m512i {
21057 unsafe { transmute(vpsrlq(a.as_i64x8(), count.as_i64x2())) }
21058}
21059
21060#[inline]
21064#[target_feature(enable = "avx512f")]
21065#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21066#[cfg_attr(test, assert_instr(vpsrlq))]
21067pub fn _mm512_mask_srl_epi64(src: __m512i, k: __mmask8, a: __m512i, count: __m128i) -> __m512i {
21068 unsafe {
21069 let shf = _mm512_srl_epi64(a, count).as_i64x8();
21070 transmute(simd_select_bitmask(k, shf, src.as_i64x8()))
21071 }
21072}
21073
21074#[inline]
21078#[target_feature(enable = "avx512f")]
21079#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21080#[cfg_attr(test, assert_instr(vpsrlq))]
21081pub fn _mm512_maskz_srl_epi64(k: __mmask8, a: __m512i, count: __m128i) -> __m512i {
21082 unsafe {
21083 let shf = _mm512_srl_epi64(a, count).as_i64x8();
21084 transmute(simd_select_bitmask(k, shf, i64x8::ZERO))
21085 }
21086}
21087
21088#[inline]
21092#[target_feature(enable = "avx512f,avx512vl")]
21093#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21094#[cfg_attr(test, assert_instr(vpsrlq))]
21095pub fn _mm256_mask_srl_epi64(src: __m256i, k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21096 unsafe {
21097 let shf = _mm256_srl_epi64(a, count).as_i64x4();
21098 transmute(simd_select_bitmask(k, shf, src.as_i64x4()))
21099 }
21100}
21101
21102#[inline]
21106#[target_feature(enable = "avx512f,avx512vl")]
21107#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21108#[cfg_attr(test, assert_instr(vpsrlq))]
21109pub fn _mm256_maskz_srl_epi64(k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21110 unsafe {
21111 let shf = _mm256_srl_epi64(a, count).as_i64x4();
21112 transmute(simd_select_bitmask(k, shf, i64x4::ZERO))
21113 }
21114}
21115
21116#[inline]
21120#[target_feature(enable = "avx512f,avx512vl")]
21121#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21122#[cfg_attr(test, assert_instr(vpsrlq))]
21123pub fn _mm_mask_srl_epi64(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21124 unsafe {
21125 let shf = _mm_srl_epi64(a, count).as_i64x2();
21126 transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
21127 }
21128}
21129
21130#[inline]
21134#[target_feature(enable = "avx512f,avx512vl")]
21135#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21136#[cfg_attr(test, assert_instr(vpsrlq))]
21137pub fn _mm_maskz_srl_epi64(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21138 unsafe {
21139 let shf = _mm_srl_epi64(a, count).as_i64x2();
21140 transmute(simd_select_bitmask(k, shf, i64x2::ZERO))
21141 }
21142}
21143
21144#[inline]
21148#[target_feature(enable = "avx512f")]
21149#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21150#[cfg_attr(test, assert_instr(vpsrad))]
21151pub fn _mm512_sra_epi32(a: __m512i, count: __m128i) -> __m512i {
21152 unsafe { transmute(vpsrad(a.as_i32x16(), count.as_i32x4())) }
21153}
21154
21155#[inline]
21159#[target_feature(enable = "avx512f")]
21160#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21161#[cfg_attr(test, assert_instr(vpsrad))]
21162pub fn _mm512_mask_sra_epi32(src: __m512i, k: __mmask16, a: __m512i, count: __m128i) -> __m512i {
21163 unsafe {
21164 let shf = _mm512_sra_epi32(a, count).as_i32x16();
21165 transmute(simd_select_bitmask(k, shf, src.as_i32x16()))
21166 }
21167}
21168
21169#[inline]
21173#[target_feature(enable = "avx512f")]
21174#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21175#[cfg_attr(test, assert_instr(vpsrad))]
21176pub fn _mm512_maskz_sra_epi32(k: __mmask16, a: __m512i, count: __m128i) -> __m512i {
21177 unsafe {
21178 let shf = _mm512_sra_epi32(a, count).as_i32x16();
21179 transmute(simd_select_bitmask(k, shf, i32x16::ZERO))
21180 }
21181}
21182
21183#[inline]
21187#[target_feature(enable = "avx512f,avx512vl")]
21188#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21189#[cfg_attr(test, assert_instr(vpsrad))]
21190pub fn _mm256_mask_sra_epi32(src: __m256i, k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21191 unsafe {
21192 let shf = _mm256_sra_epi32(a, count).as_i32x8();
21193 transmute(simd_select_bitmask(k, shf, src.as_i32x8()))
21194 }
21195}
21196
21197#[inline]
21201#[target_feature(enable = "avx512f,avx512vl")]
21202#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21203#[cfg_attr(test, assert_instr(vpsrad))]
21204pub fn _mm256_maskz_sra_epi32(k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21205 unsafe {
21206 let shf = _mm256_sra_epi32(a, count).as_i32x8();
21207 transmute(simd_select_bitmask(k, shf, i32x8::ZERO))
21208 }
21209}
21210
21211#[inline]
21215#[target_feature(enable = "avx512f,avx512vl")]
21216#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21217#[cfg_attr(test, assert_instr(vpsrad))]
21218pub fn _mm_mask_sra_epi32(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21219 unsafe {
21220 let shf = _mm_sra_epi32(a, count).as_i32x4();
21221 transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
21222 }
21223}
21224
21225#[inline]
21229#[target_feature(enable = "avx512f,avx512vl")]
21230#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21231#[cfg_attr(test, assert_instr(vpsrad))]
21232pub fn _mm_maskz_sra_epi32(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21233 unsafe {
21234 let shf = _mm_sra_epi32(a, count).as_i32x4();
21235 transmute(simd_select_bitmask(k, shf, i32x4::ZERO))
21236 }
21237}
21238
21239#[inline]
21243#[target_feature(enable = "avx512f")]
21244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21245#[cfg_attr(test, assert_instr(vpsraq))]
21246pub fn _mm512_sra_epi64(a: __m512i, count: __m128i) -> __m512i {
21247 unsafe { transmute(vpsraq(a.as_i64x8(), count.as_i64x2())) }
21248}
21249
21250#[inline]
21254#[target_feature(enable = "avx512f")]
21255#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21256#[cfg_attr(test, assert_instr(vpsraq))]
21257pub fn _mm512_mask_sra_epi64(src: __m512i, k: __mmask8, a: __m512i, count: __m128i) -> __m512i {
21258 unsafe {
21259 let shf = _mm512_sra_epi64(a, count).as_i64x8();
21260 transmute(simd_select_bitmask(k, shf, src.as_i64x8()))
21261 }
21262}
21263
21264#[inline]
21268#[target_feature(enable = "avx512f")]
21269#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21270#[cfg_attr(test, assert_instr(vpsraq))]
21271pub fn _mm512_maskz_sra_epi64(k: __mmask8, a: __m512i, count: __m128i) -> __m512i {
21272 unsafe {
21273 let shf = _mm512_sra_epi64(a, count).as_i64x8();
21274 transmute(simd_select_bitmask(k, shf, i64x8::ZERO))
21275 }
21276}
21277
21278#[inline]
21282#[target_feature(enable = "avx512f,avx512vl")]
21283#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21284#[cfg_attr(test, assert_instr(vpsraq))]
21285pub fn _mm256_sra_epi64(a: __m256i, count: __m128i) -> __m256i {
21286 unsafe { transmute(vpsraq256(a.as_i64x4(), count.as_i64x2())) }
21287}
21288
21289#[inline]
21293#[target_feature(enable = "avx512f,avx512vl")]
21294#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21295#[cfg_attr(test, assert_instr(vpsraq))]
21296pub fn _mm256_mask_sra_epi64(src: __m256i, k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21297 unsafe {
21298 let shf = _mm256_sra_epi64(a, count).as_i64x4();
21299 transmute(simd_select_bitmask(k, shf, src.as_i64x4()))
21300 }
21301}
21302
21303#[inline]
21307#[target_feature(enable = "avx512f,avx512vl")]
21308#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21309#[cfg_attr(test, assert_instr(vpsraq))]
21310pub fn _mm256_maskz_sra_epi64(k: __mmask8, a: __m256i, count: __m128i) -> __m256i {
21311 unsafe {
21312 let shf = _mm256_sra_epi64(a, count).as_i64x4();
21313 transmute(simd_select_bitmask(k, shf, i64x4::ZERO))
21314 }
21315}
21316
21317#[inline]
21321#[target_feature(enable = "avx512f,avx512vl")]
21322#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21323#[cfg_attr(test, assert_instr(vpsraq))]
21324pub fn _mm_sra_epi64(a: __m128i, count: __m128i) -> __m128i {
21325 unsafe { transmute(vpsraq128(a.as_i64x2(), count.as_i64x2())) }
21326}
21327
21328#[inline]
21332#[target_feature(enable = "avx512f,avx512vl")]
21333#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21334#[cfg_attr(test, assert_instr(vpsraq))]
21335pub fn _mm_mask_sra_epi64(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21336 unsafe {
21337 let shf = _mm_sra_epi64(a, count).as_i64x2();
21338 transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
21339 }
21340}
21341
21342#[inline]
21346#[target_feature(enable = "avx512f,avx512vl")]
21347#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21348#[cfg_attr(test, assert_instr(vpsraq))]
21349pub fn _mm_maskz_sra_epi64(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21350 unsafe {
21351 let shf = _mm_sra_epi64(a, count).as_i64x2();
21352 transmute(simd_select_bitmask(k, shf, i64x2::ZERO))
21353 }
21354}
21355
21356#[inline]
21360#[target_feature(enable = "avx512f")]
21361#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21362#[cfg_attr(test, assert_instr(vpsrad, IMM8 = 1))]
21363#[rustc_legacy_const_generics(1)]
21364#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21365pub const fn _mm512_srai_epi32<const IMM8: u32>(a: __m512i) -> __m512i {
21366 unsafe {
21367 static_assert_uimm_bits!(IMM8, 8);
21368 transmute(simd_shr(a.as_i32x16(), i32x16::splat(IMM8.min(31) as i32)))
21369 }
21370}
21371
21372#[inline]
21376#[target_feature(enable = "avx512f")]
21377#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21378#[cfg_attr(test, assert_instr(vpsrad, IMM8 = 1))]
21379#[rustc_legacy_const_generics(3)]
21380#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21381pub const fn _mm512_mask_srai_epi32<const IMM8: u32>(
21382 src: __m512i,
21383 k: __mmask16,
21384 a: __m512i,
21385) -> __m512i {
21386 unsafe {
21387 static_assert_uimm_bits!(IMM8, 8);
21388 let r = simd_shr(a.as_i32x16(), i32x16::splat(IMM8.min(31) as i32));
21389 transmute(simd_select_bitmask(k, r, src.as_i32x16()))
21390 }
21391}
21392
21393#[inline]
21397#[target_feature(enable = "avx512f")]
21398#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21399#[cfg_attr(test, assert_instr(vpsrad, IMM8 = 1))]
21400#[rustc_legacy_const_generics(2)]
21401#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21402pub const fn _mm512_maskz_srai_epi32<const IMM8: u32>(k: __mmask16, a: __m512i) -> __m512i {
21403 unsafe {
21404 static_assert_uimm_bits!(IMM8, 8);
21405 let r = simd_shr(a.as_i32x16(), i32x16::splat(IMM8.min(31) as i32));
21406 transmute(simd_select_bitmask(k, r, i32x16::ZERO))
21407 }
21408}
21409
21410#[inline]
21414#[target_feature(enable = "avx512f,avx512vl")]
21415#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21416#[cfg_attr(test, assert_instr(vpsrad, IMM8 = 1))]
21417#[rustc_legacy_const_generics(3)]
21418#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21419pub const fn _mm256_mask_srai_epi32<const IMM8: u32>(
21420 src: __m256i,
21421 k: __mmask8,
21422 a: __m256i,
21423) -> __m256i {
21424 unsafe {
21425 let r = simd_shr(a.as_i32x8(), i32x8::splat(IMM8.min(31) as i32));
21426 transmute(simd_select_bitmask(k, r, src.as_i32x8()))
21427 }
21428}
21429
21430#[inline]
21434#[target_feature(enable = "avx512f,avx512vl")]
21435#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21436#[cfg_attr(test, assert_instr(vpsrad, IMM8 = 1))]
21437#[rustc_legacy_const_generics(2)]
21438#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21439pub const fn _mm256_maskz_srai_epi32<const IMM8: u32>(k: __mmask8, a: __m256i) -> __m256i {
21440 unsafe {
21441 let r = simd_shr(a.as_i32x8(), i32x8::splat(IMM8.min(31) as i32));
21442 transmute(simd_select_bitmask(k, r, i32x8::ZERO))
21443 }
21444}
21445
21446#[inline]
21450#[target_feature(enable = "avx512f,avx512vl")]
21451#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21452#[cfg_attr(test, assert_instr(vpsrad, IMM8 = 1))]
21453#[rustc_legacy_const_generics(3)]
21454#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21455pub const fn _mm_mask_srai_epi32<const IMM8: u32>(
21456 src: __m128i,
21457 k: __mmask8,
21458 a: __m128i,
21459) -> __m128i {
21460 unsafe {
21461 let r = simd_shr(a.as_i32x4(), i32x4::splat(IMM8.min(31) as i32));
21462 transmute(simd_select_bitmask(k, r, src.as_i32x4()))
21463 }
21464}
21465
21466#[inline]
21470#[target_feature(enable = "avx512f,avx512vl")]
21471#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21472#[cfg_attr(test, assert_instr(vpsrad, IMM8 = 1))]
21473#[rustc_legacy_const_generics(2)]
21474#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21475pub const fn _mm_maskz_srai_epi32<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
21476 unsafe {
21477 let r = simd_shr(a.as_i32x4(), i32x4::splat(IMM8.min(31) as i32));
21478 transmute(simd_select_bitmask(k, r, i32x4::ZERO))
21479 }
21480}
21481
21482#[inline]
21486#[target_feature(enable = "avx512f")]
21487#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21488#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21489#[rustc_legacy_const_generics(1)]
21490#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21491pub const fn _mm512_srai_epi64<const IMM8: u32>(a: __m512i) -> __m512i {
21492 unsafe {
21493 static_assert_uimm_bits!(IMM8, 8);
21494 transmute(simd_shr(a.as_i64x8(), i64x8::splat(IMM8.min(63) as i64)))
21495 }
21496}
21497
21498#[inline]
21502#[target_feature(enable = "avx512f")]
21503#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21504#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21505#[rustc_legacy_const_generics(3)]
21506#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21507pub const fn _mm512_mask_srai_epi64<const IMM8: u32>(
21508 src: __m512i,
21509 k: __mmask8,
21510 a: __m512i,
21511) -> __m512i {
21512 unsafe {
21513 static_assert_uimm_bits!(IMM8, 8);
21514 let shf = simd_shr(a.as_i64x8(), i64x8::splat(IMM8.min(63) as i64));
21515 transmute(simd_select_bitmask(k, shf, src.as_i64x8()))
21516 }
21517}
21518
21519#[inline]
21523#[target_feature(enable = "avx512f")]
21524#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21525#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21526#[rustc_legacy_const_generics(2)]
21527#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21528pub const fn _mm512_maskz_srai_epi64<const IMM8: u32>(k: __mmask8, a: __m512i) -> __m512i {
21529 unsafe {
21530 static_assert_uimm_bits!(IMM8, 8);
21531 let shf = simd_shr(a.as_i64x8(), i64x8::splat(IMM8.min(63) as i64));
21532 transmute(simd_select_bitmask(k, shf, i64x8::ZERO))
21533 }
21534}
21535
21536#[inline]
21540#[target_feature(enable = "avx512f,avx512vl")]
21541#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21542#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21543#[rustc_legacy_const_generics(1)]
21544#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21545pub const fn _mm256_srai_epi64<const IMM8: u32>(a: __m256i) -> __m256i {
21546 unsafe {
21547 static_assert_uimm_bits!(IMM8, 8);
21548 transmute(simd_shr(a.as_i64x4(), i64x4::splat(IMM8.min(63) as i64)))
21549 }
21550}
21551
21552#[inline]
21556#[target_feature(enable = "avx512f,avx512vl")]
21557#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21558#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21559#[rustc_legacy_const_generics(3)]
21560#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21561pub const fn _mm256_mask_srai_epi64<const IMM8: u32>(
21562 src: __m256i,
21563 k: __mmask8,
21564 a: __m256i,
21565) -> __m256i {
21566 unsafe {
21567 static_assert_uimm_bits!(IMM8, 8);
21568 let shf = simd_shr(a.as_i64x4(), i64x4::splat(IMM8.min(63) as i64));
21569 transmute(simd_select_bitmask(k, shf, src.as_i64x4()))
21570 }
21571}
21572
21573#[inline]
21577#[target_feature(enable = "avx512f,avx512vl")]
21578#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21579#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21580#[rustc_legacy_const_generics(2)]
21581#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21582pub const fn _mm256_maskz_srai_epi64<const IMM8: u32>(k: __mmask8, a: __m256i) -> __m256i {
21583 unsafe {
21584 static_assert_uimm_bits!(IMM8, 8);
21585 let shf = simd_shr(a.as_i64x4(), i64x4::splat(IMM8.min(63) as i64));
21586 transmute(simd_select_bitmask(k, shf, i64x4::ZERO))
21587 }
21588}
21589
21590#[inline]
21594#[target_feature(enable = "avx512f,avx512vl")]
21595#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21596#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21597#[rustc_legacy_const_generics(1)]
21598#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21599pub const fn _mm_srai_epi64<const IMM8: u32>(a: __m128i) -> __m128i {
21600 unsafe {
21601 static_assert_uimm_bits!(IMM8, 8);
21602 transmute(simd_shr(a.as_i64x2(), i64x2::splat(IMM8.min(63) as i64)))
21603 }
21604}
21605
21606#[inline]
21610#[target_feature(enable = "avx512f,avx512vl")]
21611#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21612#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21613#[rustc_legacy_const_generics(3)]
21614#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21615pub const fn _mm_mask_srai_epi64<const IMM8: u32>(
21616 src: __m128i,
21617 k: __mmask8,
21618 a: __m128i,
21619) -> __m128i {
21620 unsafe {
21621 static_assert_uimm_bits!(IMM8, 8);
21622 let shf = simd_shr(a.as_i64x2(), i64x2::splat(IMM8.min(63) as i64));
21623 transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
21624 }
21625}
21626
21627#[inline]
21631#[target_feature(enable = "avx512f,avx512vl")]
21632#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21633#[cfg_attr(test, assert_instr(vpsraq, IMM8 = 1))]
21634#[rustc_legacy_const_generics(2)]
21635#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21636pub const fn _mm_maskz_srai_epi64<const IMM8: u32>(k: __mmask8, a: __m128i) -> __m128i {
21637 unsafe {
21638 static_assert_uimm_bits!(IMM8, 8);
21639 let shf = simd_shr(a.as_i64x2(), i64x2::splat(IMM8.min(63) as i64));
21640 transmute(simd_select_bitmask(k, shf, i64x2::ZERO))
21641 }
21642}
21643
21644#[inline]
21648#[target_feature(enable = "avx512f")]
21649#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21650#[cfg_attr(test, assert_instr(vpsravd))]
21651pub fn _mm512_srav_epi32(a: __m512i, count: __m512i) -> __m512i {
21652 unsafe { transmute(vpsravd(a.as_i32x16(), count.as_i32x16())) }
21653}
21654
21655#[inline]
21659#[target_feature(enable = "avx512f")]
21660#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21661#[cfg_attr(test, assert_instr(vpsravd))]
21662pub fn _mm512_mask_srav_epi32(src: __m512i, k: __mmask16, a: __m512i, count: __m512i) -> __m512i {
21663 unsafe {
21664 let shf = _mm512_srav_epi32(a, count).as_i32x16();
21665 transmute(simd_select_bitmask(k, shf, src.as_i32x16()))
21666 }
21667}
21668
21669#[inline]
21673#[target_feature(enable = "avx512f")]
21674#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21675#[cfg_attr(test, assert_instr(vpsravd))]
21676pub fn _mm512_maskz_srav_epi32(k: __mmask16, a: __m512i, count: __m512i) -> __m512i {
21677 unsafe {
21678 let shf = _mm512_srav_epi32(a, count).as_i32x16();
21679 transmute(simd_select_bitmask(k, shf, i32x16::ZERO))
21680 }
21681}
21682
21683#[inline]
21687#[target_feature(enable = "avx512f,avx512vl")]
21688#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21689#[cfg_attr(test, assert_instr(vpsravd))]
21690pub fn _mm256_mask_srav_epi32(src: __m256i, k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
21691 unsafe {
21692 let shf = _mm256_srav_epi32(a, count).as_i32x8();
21693 transmute(simd_select_bitmask(k, shf, src.as_i32x8()))
21694 }
21695}
21696
21697#[inline]
21701#[target_feature(enable = "avx512f,avx512vl")]
21702#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21703#[cfg_attr(test, assert_instr(vpsravd))]
21704pub fn _mm256_maskz_srav_epi32(k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
21705 unsafe {
21706 let shf = _mm256_srav_epi32(a, count).as_i32x8();
21707 transmute(simd_select_bitmask(k, shf, i32x8::ZERO))
21708 }
21709}
21710
21711#[inline]
21715#[target_feature(enable = "avx512f,avx512vl")]
21716#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21717#[cfg_attr(test, assert_instr(vpsravd))]
21718pub fn _mm_mask_srav_epi32(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21719 unsafe {
21720 let shf = _mm_srav_epi32(a, count).as_i32x4();
21721 transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
21722 }
21723}
21724
21725#[inline]
21729#[target_feature(enable = "avx512f,avx512vl")]
21730#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21731#[cfg_attr(test, assert_instr(vpsravd))]
21732pub fn _mm_maskz_srav_epi32(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21733 unsafe {
21734 let shf = _mm_srav_epi32(a, count).as_i32x4();
21735 transmute(simd_select_bitmask(k, shf, i32x4::ZERO))
21736 }
21737}
21738
21739#[inline]
21743#[target_feature(enable = "avx512f")]
21744#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21745#[cfg_attr(test, assert_instr(vpsravq))]
21746pub fn _mm512_srav_epi64(a: __m512i, count: __m512i) -> __m512i {
21747 unsafe { transmute(vpsravq(a.as_i64x8(), count.as_i64x8())) }
21748}
21749
21750#[inline]
21754#[target_feature(enable = "avx512f")]
21755#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21756#[cfg_attr(test, assert_instr(vpsravq))]
21757pub fn _mm512_mask_srav_epi64(src: __m512i, k: __mmask8, a: __m512i, count: __m512i) -> __m512i {
21758 unsafe {
21759 let shf = _mm512_srav_epi64(a, count).as_i64x8();
21760 transmute(simd_select_bitmask(k, shf, src.as_i64x8()))
21761 }
21762}
21763
21764#[inline]
21768#[target_feature(enable = "avx512f")]
21769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21770#[cfg_attr(test, assert_instr(vpsravq))]
21771pub fn _mm512_maskz_srav_epi64(k: __mmask8, a: __m512i, count: __m512i) -> __m512i {
21772 unsafe {
21773 let shf = _mm512_srav_epi64(a, count).as_i64x8();
21774 transmute(simd_select_bitmask(k, shf, i64x8::ZERO))
21775 }
21776}
21777
21778#[inline]
21782#[target_feature(enable = "avx512f,avx512vl")]
21783#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21784#[cfg_attr(test, assert_instr(vpsravq))]
21785pub fn _mm256_srav_epi64(a: __m256i, count: __m256i) -> __m256i {
21786 unsafe { transmute(vpsravq256(a.as_i64x4(), count.as_i64x4())) }
21787}
21788
21789#[inline]
21793#[target_feature(enable = "avx512f,avx512vl")]
21794#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21795#[cfg_attr(test, assert_instr(vpsravq))]
21796pub fn _mm256_mask_srav_epi64(src: __m256i, k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
21797 unsafe {
21798 let shf = _mm256_srav_epi64(a, count).as_i64x4();
21799 transmute(simd_select_bitmask(k, shf, src.as_i64x4()))
21800 }
21801}
21802
21803#[inline]
21807#[target_feature(enable = "avx512f,avx512vl")]
21808#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21809#[cfg_attr(test, assert_instr(vpsravq))]
21810pub fn _mm256_maskz_srav_epi64(k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
21811 unsafe {
21812 let shf = _mm256_srav_epi64(a, count).as_i64x4();
21813 transmute(simd_select_bitmask(k, shf, i64x4::ZERO))
21814 }
21815}
21816
21817#[inline]
21821#[target_feature(enable = "avx512f,avx512vl")]
21822#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21823#[cfg_attr(test, assert_instr(vpsravq))]
21824pub fn _mm_srav_epi64(a: __m128i, count: __m128i) -> __m128i {
21825 unsafe { transmute(vpsravq128(a.as_i64x2(), count.as_i64x2())) }
21826}
21827
21828#[inline]
21832#[target_feature(enable = "avx512f,avx512vl")]
21833#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21834#[cfg_attr(test, assert_instr(vpsravq))]
21835pub fn _mm_mask_srav_epi64(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21836 unsafe {
21837 let shf = _mm_srav_epi64(a, count).as_i64x2();
21838 transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
21839 }
21840}
21841
21842#[inline]
21846#[target_feature(enable = "avx512f,avx512vl")]
21847#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21848#[cfg_attr(test, assert_instr(vpsravq))]
21849pub fn _mm_maskz_srav_epi64(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
21850 unsafe {
21851 let shf = _mm_srav_epi64(a, count).as_i64x2();
21852 transmute(simd_select_bitmask(k, shf, i64x2::ZERO))
21853 }
21854}
21855
21856#[inline]
21860#[target_feature(enable = "avx512f")]
21861#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21862#[cfg_attr(test, assert_instr(vprolvd))]
21863#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21864pub const fn _mm512_rolv_epi32(a: __m512i, b: __m512i) -> __m512i {
21865 unsafe {
21866 transmute(simd_funnel_shl(
21867 a.as_u32x16(),
21868 a.as_u32x16(),
21869 simd_and(b.as_u32x16(), u32x16::splat(31)),
21870 ))
21871 }
21872}
21873
21874#[inline]
21878#[target_feature(enable = "avx512f")]
21879#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21880#[cfg_attr(test, assert_instr(vprolvd))]
21881#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21882pub const fn _mm512_mask_rolv_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
21883 unsafe {
21884 let rol = _mm512_rolv_epi32(a, b).as_i32x16();
21885 transmute(simd_select_bitmask(k, rol, src.as_i32x16()))
21886 }
21887}
21888
21889#[inline]
21893#[target_feature(enable = "avx512f")]
21894#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21895#[cfg_attr(test, assert_instr(vprolvd))]
21896#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21897pub const fn _mm512_maskz_rolv_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
21898 unsafe {
21899 let rol = _mm512_rolv_epi32(a, b).as_i32x16();
21900 transmute(simd_select_bitmask(k, rol, i32x16::ZERO))
21901 }
21902}
21903
21904#[inline]
21908#[target_feature(enable = "avx512f,avx512vl")]
21909#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21910#[cfg_attr(test, assert_instr(vprolvd))]
21911#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21912pub const fn _mm256_rolv_epi32(a: __m256i, b: __m256i) -> __m256i {
21913 unsafe {
21914 transmute(simd_funnel_shl(
21915 a.as_u32x8(),
21916 a.as_u32x8(),
21917 simd_and(b.as_u32x8(), u32x8::splat(31)),
21918 ))
21919 }
21920}
21921
21922#[inline]
21926#[target_feature(enable = "avx512f,avx512vl")]
21927#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21928#[cfg_attr(test, assert_instr(vprolvd))]
21929#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21930pub const fn _mm256_mask_rolv_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
21931 unsafe {
21932 let rol = _mm256_rolv_epi32(a, b).as_i32x8();
21933 transmute(simd_select_bitmask(k, rol, src.as_i32x8()))
21934 }
21935}
21936
21937#[inline]
21941#[target_feature(enable = "avx512f,avx512vl")]
21942#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21943#[cfg_attr(test, assert_instr(vprolvd))]
21944#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21945pub const fn _mm256_maskz_rolv_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
21946 unsafe {
21947 let rol = _mm256_rolv_epi32(a, b).as_i32x8();
21948 transmute(simd_select_bitmask(k, rol, i32x8::ZERO))
21949 }
21950}
21951
21952#[inline]
21956#[target_feature(enable = "avx512f,avx512vl")]
21957#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21958#[cfg_attr(test, assert_instr(vprolvd))]
21959#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21960pub const fn _mm_rolv_epi32(a: __m128i, b: __m128i) -> __m128i {
21961 unsafe {
21962 transmute(simd_funnel_shl(
21963 a.as_u32x4(),
21964 a.as_u32x4(),
21965 simd_and(b.as_u32x4(), u32x4::splat(31)),
21966 ))
21967 }
21968}
21969
21970#[inline]
21974#[target_feature(enable = "avx512f,avx512vl")]
21975#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21976#[cfg_attr(test, assert_instr(vprolvd))]
21977#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21978pub const fn _mm_mask_rolv_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
21979 unsafe {
21980 let rol = _mm_rolv_epi32(a, b).as_i32x4();
21981 transmute(simd_select_bitmask(k, rol, src.as_i32x4()))
21982 }
21983}
21984
21985#[inline]
21989#[target_feature(enable = "avx512f,avx512vl")]
21990#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
21991#[cfg_attr(test, assert_instr(vprolvd))]
21992#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
21993pub const fn _mm_maskz_rolv_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
21994 unsafe {
21995 let rol = _mm_rolv_epi32(a, b).as_i32x4();
21996 transmute(simd_select_bitmask(k, rol, i32x4::ZERO))
21997 }
21998}
21999
22000#[inline]
22004#[target_feature(enable = "avx512f")]
22005#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22006#[cfg_attr(test, assert_instr(vprorvd))]
22007#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22008pub const fn _mm512_rorv_epi32(a: __m512i, b: __m512i) -> __m512i {
22009 unsafe {
22010 transmute(simd_funnel_shr(
22011 a.as_u32x16(),
22012 a.as_u32x16(),
22013 simd_and(b.as_u32x16(), u32x16::splat(31)),
22014 ))
22015 }
22016}
22017
22018#[inline]
22022#[target_feature(enable = "avx512f")]
22023#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22024#[cfg_attr(test, assert_instr(vprorvd))]
22025#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22026pub const fn _mm512_mask_rorv_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
22027 unsafe {
22028 let ror = _mm512_rorv_epi32(a, b).as_i32x16();
22029 transmute(simd_select_bitmask(k, ror, src.as_i32x16()))
22030 }
22031}
22032
22033#[inline]
22037#[target_feature(enable = "avx512f")]
22038#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22039#[cfg_attr(test, assert_instr(vprorvd))]
22040#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22041pub const fn _mm512_maskz_rorv_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
22042 unsafe {
22043 let ror = _mm512_rorv_epi32(a, b).as_i32x16();
22044 transmute(simd_select_bitmask(k, ror, i32x16::ZERO))
22045 }
22046}
22047
22048#[inline]
22052#[target_feature(enable = "avx512f,avx512vl")]
22053#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22054#[cfg_attr(test, assert_instr(vprorvd))]
22055#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22056pub const fn _mm256_rorv_epi32(a: __m256i, b: __m256i) -> __m256i {
22057 unsafe {
22058 transmute(simd_funnel_shr(
22059 a.as_u32x8(),
22060 a.as_u32x8(),
22061 simd_and(b.as_u32x8(), u32x8::splat(31)),
22062 ))
22063 }
22064}
22065
22066#[inline]
22070#[target_feature(enable = "avx512f,avx512vl")]
22071#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22072#[cfg_attr(test, assert_instr(vprorvd))]
22073#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22074pub const fn _mm256_mask_rorv_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
22075 unsafe {
22076 let ror = _mm256_rorv_epi32(a, b).as_i32x8();
22077 transmute(simd_select_bitmask(k, ror, src.as_i32x8()))
22078 }
22079}
22080
22081#[inline]
22085#[target_feature(enable = "avx512f,avx512vl")]
22086#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22087#[cfg_attr(test, assert_instr(vprorvd))]
22088#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22089pub const fn _mm256_maskz_rorv_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
22090 unsafe {
22091 let ror = _mm256_rorv_epi32(a, b).as_i32x8();
22092 transmute(simd_select_bitmask(k, ror, i32x8::ZERO))
22093 }
22094}
22095
22096#[inline]
22100#[target_feature(enable = "avx512f,avx512vl")]
22101#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22102#[cfg_attr(test, assert_instr(vprorvd))]
22103#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22104pub const fn _mm_rorv_epi32(a: __m128i, b: __m128i) -> __m128i {
22105 unsafe {
22106 transmute(simd_funnel_shr(
22107 a.as_u32x4(),
22108 a.as_u32x4(),
22109 simd_and(b.as_u32x4(), u32x4::splat(31)),
22110 ))
22111 }
22112}
22113
22114#[inline]
22118#[target_feature(enable = "avx512f,avx512vl")]
22119#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22120#[cfg_attr(test, assert_instr(vprorvd))]
22121#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22122pub const fn _mm_mask_rorv_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
22123 unsafe {
22124 let ror = _mm_rorv_epi32(a, b).as_i32x4();
22125 transmute(simd_select_bitmask(k, ror, src.as_i32x4()))
22126 }
22127}
22128
22129#[inline]
22133#[target_feature(enable = "avx512f,avx512vl")]
22134#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22135#[cfg_attr(test, assert_instr(vprorvd))]
22136#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22137pub const fn _mm_maskz_rorv_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
22138 unsafe {
22139 let ror = _mm_rorv_epi32(a, b).as_i32x4();
22140 transmute(simd_select_bitmask(k, ror, i32x4::ZERO))
22141 }
22142}
22143
22144#[inline]
22148#[target_feature(enable = "avx512f")]
22149#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22150#[cfg_attr(test, assert_instr(vprolvq))]
22151#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22152pub const fn _mm512_rolv_epi64(a: __m512i, b: __m512i) -> __m512i {
22153 unsafe {
22154 transmute(simd_funnel_shl(
22155 a.as_u64x8(),
22156 a.as_u64x8(),
22157 simd_and(b.as_u64x8(), u64x8::splat(63)),
22158 ))
22159 }
22160}
22161
22162#[inline]
22166#[target_feature(enable = "avx512f")]
22167#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22168#[cfg_attr(test, assert_instr(vprolvq))]
22169#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22170pub const fn _mm512_mask_rolv_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
22171 unsafe {
22172 let rol = _mm512_rolv_epi64(a, b).as_i64x8();
22173 transmute(simd_select_bitmask(k, rol, src.as_i64x8()))
22174 }
22175}
22176
22177#[inline]
22181#[target_feature(enable = "avx512f")]
22182#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22183#[cfg_attr(test, assert_instr(vprolvq))]
22184#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22185pub const fn _mm512_maskz_rolv_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
22186 unsafe {
22187 let rol = _mm512_rolv_epi64(a, b).as_i64x8();
22188 transmute(simd_select_bitmask(k, rol, i64x8::ZERO))
22189 }
22190}
22191
22192#[inline]
22196#[target_feature(enable = "avx512f,avx512vl")]
22197#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22198#[cfg_attr(test, assert_instr(vprolvq))]
22199#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22200pub const fn _mm256_rolv_epi64(a: __m256i, b: __m256i) -> __m256i {
22201 unsafe {
22202 transmute(simd_funnel_shl(
22203 a.as_u64x4(),
22204 a.as_u64x4(),
22205 simd_and(b.as_u64x4(), u64x4::splat(63)),
22206 ))
22207 }
22208}
22209
22210#[inline]
22214#[target_feature(enable = "avx512f,avx512vl")]
22215#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22216#[cfg_attr(test, assert_instr(vprolvq))]
22217#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22218pub const fn _mm256_mask_rolv_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
22219 unsafe {
22220 let rol = _mm256_rolv_epi64(a, b).as_i64x4();
22221 transmute(simd_select_bitmask(k, rol, src.as_i64x4()))
22222 }
22223}
22224
22225#[inline]
22229#[target_feature(enable = "avx512f,avx512vl")]
22230#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22231#[cfg_attr(test, assert_instr(vprolvq))]
22232#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22233pub const fn _mm256_maskz_rolv_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
22234 unsafe {
22235 let rol = _mm256_rolv_epi64(a, b).as_i64x4();
22236 transmute(simd_select_bitmask(k, rol, i64x4::ZERO))
22237 }
22238}
22239
22240#[inline]
22244#[target_feature(enable = "avx512f,avx512vl")]
22245#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22246#[cfg_attr(test, assert_instr(vprolvq))]
22247#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22248pub const fn _mm_rolv_epi64(a: __m128i, b: __m128i) -> __m128i {
22249 unsafe {
22250 transmute(simd_funnel_shl(
22251 a.as_u64x2(),
22252 a.as_u64x2(),
22253 simd_and(b.as_u64x2(), u64x2::splat(63)),
22254 ))
22255 }
22256}
22257
22258#[inline]
22262#[target_feature(enable = "avx512f,avx512vl")]
22263#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22264#[cfg_attr(test, assert_instr(vprolvq))]
22265#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22266pub const fn _mm_mask_rolv_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
22267 unsafe {
22268 let rol = _mm_rolv_epi64(a, b).as_i64x2();
22269 transmute(simd_select_bitmask(k, rol, src.as_i64x2()))
22270 }
22271}
22272
22273#[inline]
22277#[target_feature(enable = "avx512f,avx512vl")]
22278#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22279#[cfg_attr(test, assert_instr(vprolvq))]
22280#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22281pub const fn _mm_maskz_rolv_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
22282 unsafe {
22283 let rol = _mm_rolv_epi64(a, b).as_i64x2();
22284 transmute(simd_select_bitmask(k, rol, i64x2::ZERO))
22285 }
22286}
22287
22288#[inline]
22292#[target_feature(enable = "avx512f")]
22293#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22294#[cfg_attr(test, assert_instr(vprorvq))]
22295#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22296pub const fn _mm512_rorv_epi64(a: __m512i, b: __m512i) -> __m512i {
22297 unsafe {
22298 transmute(simd_funnel_shr(
22299 a.as_u64x8(),
22300 a.as_u64x8(),
22301 simd_and(b.as_u64x8(), u64x8::splat(63)),
22302 ))
22303 }
22304}
22305
22306#[inline]
22310#[target_feature(enable = "avx512f")]
22311#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22312#[cfg_attr(test, assert_instr(vprorvq))]
22313#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22314pub const fn _mm512_mask_rorv_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
22315 unsafe {
22316 let ror = _mm512_rorv_epi64(a, b).as_i64x8();
22317 transmute(simd_select_bitmask(k, ror, src.as_i64x8()))
22318 }
22319}
22320
22321#[inline]
22325#[target_feature(enable = "avx512f")]
22326#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22327#[cfg_attr(test, assert_instr(vprorvq))]
22328#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22329pub const fn _mm512_maskz_rorv_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
22330 unsafe {
22331 let ror = _mm512_rorv_epi64(a, b).as_i64x8();
22332 transmute(simd_select_bitmask(k, ror, i64x8::ZERO))
22333 }
22334}
22335
22336#[inline]
22340#[target_feature(enable = "avx512f,avx512vl")]
22341#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22342#[cfg_attr(test, assert_instr(vprorvq))]
22343#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22344pub const fn _mm256_rorv_epi64(a: __m256i, b: __m256i) -> __m256i {
22345 unsafe {
22346 transmute(simd_funnel_shr(
22347 a.as_u64x4(),
22348 a.as_u64x4(),
22349 simd_and(b.as_u64x4(), u64x4::splat(63)),
22350 ))
22351 }
22352}
22353
22354#[inline]
22358#[target_feature(enable = "avx512f,avx512vl")]
22359#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22360#[cfg_attr(test, assert_instr(vprorvq))]
22361#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22362pub const fn _mm256_mask_rorv_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
22363 unsafe {
22364 let ror = _mm256_rorv_epi64(a, b).as_i64x4();
22365 transmute(simd_select_bitmask(k, ror, src.as_i64x4()))
22366 }
22367}
22368
22369#[inline]
22373#[target_feature(enable = "avx512f,avx512vl")]
22374#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22375#[cfg_attr(test, assert_instr(vprorvq))]
22376#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22377pub const fn _mm256_maskz_rorv_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
22378 unsafe {
22379 let ror = _mm256_rorv_epi64(a, b).as_i64x4();
22380 transmute(simd_select_bitmask(k, ror, i64x4::ZERO))
22381 }
22382}
22383
22384#[inline]
22388#[target_feature(enable = "avx512f,avx512vl")]
22389#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22390#[cfg_attr(test, assert_instr(vprorvq))]
22391#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22392pub const fn _mm_rorv_epi64(a: __m128i, b: __m128i) -> __m128i {
22393 unsafe {
22394 transmute(simd_funnel_shr(
22395 a.as_u64x2(),
22396 a.as_u64x2(),
22397 simd_and(b.as_u64x2(), u64x2::splat(63)),
22398 ))
22399 }
22400}
22401
22402#[inline]
22406#[target_feature(enable = "avx512f,avx512vl")]
22407#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22408#[cfg_attr(test, assert_instr(vprorvq))]
22409#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22410pub const fn _mm_mask_rorv_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
22411 unsafe {
22412 let ror = _mm_rorv_epi64(a, b).as_i64x2();
22413 transmute(simd_select_bitmask(k, ror, src.as_i64x2()))
22414 }
22415}
22416
22417#[inline]
22421#[target_feature(enable = "avx512f,avx512vl")]
22422#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22423#[cfg_attr(test, assert_instr(vprorvq))]
22424#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22425pub const fn _mm_maskz_rorv_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
22426 unsafe {
22427 let ror = _mm_rorv_epi64(a, b).as_i64x2();
22428 transmute(simd_select_bitmask(k, ror, i64x2::ZERO))
22429 }
22430}
22431
22432#[inline]
22436#[target_feature(enable = "avx512f")]
22437#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22438#[cfg_attr(test, assert_instr(vpsllvd))]
22439pub fn _mm512_sllv_epi32(a: __m512i, count: __m512i) -> __m512i {
22440 unsafe { transmute(vpsllvd(a.as_i32x16(), count.as_i32x16())) }
22441}
22442
22443#[inline]
22447#[target_feature(enable = "avx512f")]
22448#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22449#[cfg_attr(test, assert_instr(vpsllvd))]
22450pub fn _mm512_mask_sllv_epi32(src: __m512i, k: __mmask16, a: __m512i, count: __m512i) -> __m512i {
22451 unsafe {
22452 let shf = _mm512_sllv_epi32(a, count).as_i32x16();
22453 transmute(simd_select_bitmask(k, shf, src.as_i32x16()))
22454 }
22455}
22456
22457#[inline]
22461#[target_feature(enable = "avx512f")]
22462#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22463#[cfg_attr(test, assert_instr(vpsllvd))]
22464pub fn _mm512_maskz_sllv_epi32(k: __mmask16, a: __m512i, count: __m512i) -> __m512i {
22465 unsafe {
22466 let shf = _mm512_sllv_epi32(a, count).as_i32x16();
22467 transmute(simd_select_bitmask(k, shf, i32x16::ZERO))
22468 }
22469}
22470
22471#[inline]
22475#[target_feature(enable = "avx512f,avx512vl")]
22476#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22477#[cfg_attr(test, assert_instr(vpsllvd))]
22478pub fn _mm256_mask_sllv_epi32(src: __m256i, k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22479 unsafe {
22480 let shf = _mm256_sllv_epi32(a, count).as_i32x8();
22481 transmute(simd_select_bitmask(k, shf, src.as_i32x8()))
22482 }
22483}
22484
22485#[inline]
22489#[target_feature(enable = "avx512f,avx512vl")]
22490#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22491#[cfg_attr(test, assert_instr(vpsllvd))]
22492pub fn _mm256_maskz_sllv_epi32(k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22493 unsafe {
22494 let shf = _mm256_sllv_epi32(a, count).as_i32x8();
22495 transmute(simd_select_bitmask(k, shf, i32x8::ZERO))
22496 }
22497}
22498
22499#[inline]
22503#[target_feature(enable = "avx512f,avx512vl")]
22504#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22505#[cfg_attr(test, assert_instr(vpsllvd))]
22506pub fn _mm_mask_sllv_epi32(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22507 unsafe {
22508 let shf = _mm_sllv_epi32(a, count).as_i32x4();
22509 transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
22510 }
22511}
22512
22513#[inline]
22517#[target_feature(enable = "avx512f,avx512vl")]
22518#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22519#[cfg_attr(test, assert_instr(vpsllvd))]
22520pub fn _mm_maskz_sllv_epi32(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22521 unsafe {
22522 let shf = _mm_sllv_epi32(a, count).as_i32x4();
22523 transmute(simd_select_bitmask(k, shf, i32x4::ZERO))
22524 }
22525}
22526
22527#[inline]
22531#[target_feature(enable = "avx512f")]
22532#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22533#[cfg_attr(test, assert_instr(vpsrlvd))]
22534pub fn _mm512_srlv_epi32(a: __m512i, count: __m512i) -> __m512i {
22535 unsafe { transmute(vpsrlvd(a.as_i32x16(), count.as_i32x16())) }
22536}
22537
22538#[inline]
22542#[target_feature(enable = "avx512f")]
22543#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22544#[cfg_attr(test, assert_instr(vpsrlvd))]
22545pub fn _mm512_mask_srlv_epi32(src: __m512i, k: __mmask16, a: __m512i, count: __m512i) -> __m512i {
22546 unsafe {
22547 let shf = _mm512_srlv_epi32(a, count).as_i32x16();
22548 transmute(simd_select_bitmask(k, shf, src.as_i32x16()))
22549 }
22550}
22551
22552#[inline]
22556#[target_feature(enable = "avx512f")]
22557#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22558#[cfg_attr(test, assert_instr(vpsrlvd))]
22559pub fn _mm512_maskz_srlv_epi32(k: __mmask16, a: __m512i, count: __m512i) -> __m512i {
22560 unsafe {
22561 let shf = _mm512_srlv_epi32(a, count).as_i32x16();
22562 transmute(simd_select_bitmask(k, shf, i32x16::ZERO))
22563 }
22564}
22565
22566#[inline]
22570#[target_feature(enable = "avx512f,avx512vl")]
22571#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22572#[cfg_attr(test, assert_instr(vpsrlvd))]
22573pub fn _mm256_mask_srlv_epi32(src: __m256i, k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22574 unsafe {
22575 let shf = _mm256_srlv_epi32(a, count).as_i32x8();
22576 transmute(simd_select_bitmask(k, shf, src.as_i32x8()))
22577 }
22578}
22579
22580#[inline]
22584#[target_feature(enable = "avx512f,avx512vl")]
22585#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22586#[cfg_attr(test, assert_instr(vpsrlvd))]
22587pub fn _mm256_maskz_srlv_epi32(k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22588 unsafe {
22589 let shf = _mm256_srlv_epi32(a, count).as_i32x8();
22590 transmute(simd_select_bitmask(k, shf, i32x8::ZERO))
22591 }
22592}
22593
22594#[inline]
22598#[target_feature(enable = "avx512f,avx512vl")]
22599#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22600#[cfg_attr(test, assert_instr(vpsrlvd))]
22601pub fn _mm_mask_srlv_epi32(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22602 unsafe {
22603 let shf = _mm_srlv_epi32(a, count).as_i32x4();
22604 transmute(simd_select_bitmask(k, shf, src.as_i32x4()))
22605 }
22606}
22607
22608#[inline]
22612#[target_feature(enable = "avx512f,avx512vl")]
22613#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22614#[cfg_attr(test, assert_instr(vpsrlvd))]
22615pub fn _mm_maskz_srlv_epi32(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22616 unsafe {
22617 let shf = _mm_srlv_epi32(a, count).as_i32x4();
22618 transmute(simd_select_bitmask(k, shf, i32x4::ZERO))
22619 }
22620}
22621
22622#[inline]
22626#[target_feature(enable = "avx512f")]
22627#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22628#[cfg_attr(test, assert_instr(vpsllvq))]
22629pub fn _mm512_sllv_epi64(a: __m512i, count: __m512i) -> __m512i {
22630 unsafe { transmute(vpsllvq(a.as_i64x8(), count.as_i64x8())) }
22631}
22632
22633#[inline]
22637#[target_feature(enable = "avx512f")]
22638#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22639#[cfg_attr(test, assert_instr(vpsllvq))]
22640pub fn _mm512_mask_sllv_epi64(src: __m512i, k: __mmask8, a: __m512i, count: __m512i) -> __m512i {
22641 unsafe {
22642 let shf = _mm512_sllv_epi64(a, count).as_i64x8();
22643 transmute(simd_select_bitmask(k, shf, src.as_i64x8()))
22644 }
22645}
22646
22647#[inline]
22651#[target_feature(enable = "avx512f")]
22652#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22653#[cfg_attr(test, assert_instr(vpsllvq))]
22654pub fn _mm512_maskz_sllv_epi64(k: __mmask8, a: __m512i, count: __m512i) -> __m512i {
22655 unsafe {
22656 let shf = _mm512_sllv_epi64(a, count).as_i64x8();
22657 transmute(simd_select_bitmask(k, shf, i64x8::ZERO))
22658 }
22659}
22660
22661#[inline]
22665#[target_feature(enable = "avx512f,avx512vl")]
22666#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22667#[cfg_attr(test, assert_instr(vpsllvq))]
22668pub fn _mm256_mask_sllv_epi64(src: __m256i, k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22669 unsafe {
22670 let shf = _mm256_sllv_epi64(a, count).as_i64x4();
22671 transmute(simd_select_bitmask(k, shf, src.as_i64x4()))
22672 }
22673}
22674
22675#[inline]
22679#[target_feature(enable = "avx512f,avx512vl")]
22680#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22681#[cfg_attr(test, assert_instr(vpsllvq))]
22682pub fn _mm256_maskz_sllv_epi64(k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22683 unsafe {
22684 let shf = _mm256_sllv_epi64(a, count).as_i64x4();
22685 transmute(simd_select_bitmask(k, shf, i64x4::ZERO))
22686 }
22687}
22688
22689#[inline]
22693#[target_feature(enable = "avx512f,avx512vl")]
22694#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22695#[cfg_attr(test, assert_instr(vpsllvq))]
22696pub fn _mm_mask_sllv_epi64(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22697 unsafe {
22698 let shf = _mm_sllv_epi64(a, count).as_i64x2();
22699 transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
22700 }
22701}
22702
22703#[inline]
22707#[target_feature(enable = "avx512f,avx512vl")]
22708#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22709#[cfg_attr(test, assert_instr(vpsllvq))]
22710pub fn _mm_maskz_sllv_epi64(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22711 unsafe {
22712 let shf = _mm_sllv_epi64(a, count).as_i64x2();
22713 transmute(simd_select_bitmask(k, shf, i64x2::ZERO))
22714 }
22715}
22716
22717#[inline]
22721#[target_feature(enable = "avx512f")]
22722#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22723#[cfg_attr(test, assert_instr(vpsrlvq))]
22724pub fn _mm512_srlv_epi64(a: __m512i, count: __m512i) -> __m512i {
22725 unsafe { transmute(vpsrlvq(a.as_i64x8(), count.as_i64x8())) }
22726}
22727
22728#[inline]
22732#[target_feature(enable = "avx512f")]
22733#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22734#[cfg_attr(test, assert_instr(vpsrlvq))]
22735pub fn _mm512_mask_srlv_epi64(src: __m512i, k: __mmask8, a: __m512i, count: __m512i) -> __m512i {
22736 unsafe {
22737 let shf = _mm512_srlv_epi64(a, count).as_i64x8();
22738 transmute(simd_select_bitmask(k, shf, src.as_i64x8()))
22739 }
22740}
22741
22742#[inline]
22746#[target_feature(enable = "avx512f")]
22747#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22748#[cfg_attr(test, assert_instr(vpsrlvq))]
22749pub fn _mm512_maskz_srlv_epi64(k: __mmask8, a: __m512i, count: __m512i) -> __m512i {
22750 unsafe {
22751 let shf = _mm512_srlv_epi64(a, count).as_i64x8();
22752 transmute(simd_select_bitmask(k, shf, i64x8::ZERO))
22753 }
22754}
22755
22756#[inline]
22760#[target_feature(enable = "avx512f,avx512vl")]
22761#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22762#[cfg_attr(test, assert_instr(vpsrlvq))]
22763pub fn _mm256_mask_srlv_epi64(src: __m256i, k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22764 unsafe {
22765 let shf = _mm256_srlv_epi64(a, count).as_i64x4();
22766 transmute(simd_select_bitmask(k, shf, src.as_i64x4()))
22767 }
22768}
22769
22770#[inline]
22774#[target_feature(enable = "avx512f,avx512vl")]
22775#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22776#[cfg_attr(test, assert_instr(vpsrlvq))]
22777pub fn _mm256_maskz_srlv_epi64(k: __mmask8, a: __m256i, count: __m256i) -> __m256i {
22778 unsafe {
22779 let shf = _mm256_srlv_epi64(a, count).as_i64x4();
22780 transmute(simd_select_bitmask(k, shf, i64x4::ZERO))
22781 }
22782}
22783
22784#[inline]
22788#[target_feature(enable = "avx512f,avx512vl")]
22789#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22790#[cfg_attr(test, assert_instr(vpsrlvq))]
22791pub fn _mm_mask_srlv_epi64(src: __m128i, k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22792 unsafe {
22793 let shf = _mm_srlv_epi64(a, count).as_i64x2();
22794 transmute(simd_select_bitmask(k, shf, src.as_i64x2()))
22795 }
22796}
22797
22798#[inline]
22802#[target_feature(enable = "avx512f,avx512vl")]
22803#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22804#[cfg_attr(test, assert_instr(vpsrlvq))]
22805pub fn _mm_maskz_srlv_epi64(k: __mmask8, a: __m128i, count: __m128i) -> __m128i {
22806 unsafe {
22807 let shf = _mm_srlv_epi64(a, count).as_i64x2();
22808 transmute(simd_select_bitmask(k, shf, i64x2::ZERO))
22809 }
22810}
22811
22812#[inline]
22816#[target_feature(enable = "avx512f")]
22817#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22818#[cfg_attr(test, assert_instr(vshufps, MASK = 0b11_00_01_11))]
22819#[rustc_legacy_const_generics(1)]
22820#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22821pub const fn _mm512_permute_ps<const MASK: i32>(a: __m512) -> __m512 {
22822 unsafe {
22823 static_assert_uimm_bits!(MASK, 8);
22824 simd_shuffle!(
22825 a,
22826 a,
22827 [
22828 MASK as u32 & 0b11,
22829 (MASK as u32 >> 2) & 0b11,
22830 ((MASK as u32 >> 4) & 0b11),
22831 ((MASK as u32 >> 6) & 0b11),
22832 (MASK as u32 & 0b11) + 4,
22833 ((MASK as u32 >> 2) & 0b11) + 4,
22834 ((MASK as u32 >> 4) & 0b11) + 4,
22835 ((MASK as u32 >> 6) & 0b11) + 4,
22836 (MASK as u32 & 0b11) + 8,
22837 ((MASK as u32 >> 2) & 0b11) + 8,
22838 ((MASK as u32 >> 4) & 0b11) + 8,
22839 ((MASK as u32 >> 6) & 0b11) + 8,
22840 (MASK as u32 & 0b11) + 12,
22841 ((MASK as u32 >> 2) & 0b11) + 12,
22842 ((MASK as u32 >> 4) & 0b11) + 12,
22843 ((MASK as u32 >> 6) & 0b11) + 12,
22844 ],
22845 )
22846 }
22847}
22848
22849#[inline]
22853#[target_feature(enable = "avx512f")]
22854#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22855#[cfg_attr(test, assert_instr(vshufps, MASK = 0b11_00_01_11))]
22856#[rustc_legacy_const_generics(3)]
22857#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22858pub const fn _mm512_mask_permute_ps<const MASK: i32>(
22859 src: __m512,
22860 k: __mmask16,
22861 a: __m512,
22862) -> __m512 {
22863 unsafe {
22864 static_assert_uimm_bits!(MASK, 8);
22865 let r = _mm512_permute_ps::<MASK>(a);
22866 transmute(simd_select_bitmask(k, r.as_f32x16(), src.as_f32x16()))
22867 }
22868}
22869
22870#[inline]
22874#[target_feature(enable = "avx512f")]
22875#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22876#[cfg_attr(test, assert_instr(vshufps, MASK = 0b11_00_01_11))]
22877#[rustc_legacy_const_generics(2)]
22878#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22879pub const fn _mm512_maskz_permute_ps<const MASK: i32>(k: __mmask16, a: __m512) -> __m512 {
22880 unsafe {
22881 static_assert_uimm_bits!(MASK, 8);
22882 let r = _mm512_permute_ps::<MASK>(a);
22883 transmute(simd_select_bitmask(k, r.as_f32x16(), f32x16::ZERO))
22884 }
22885}
22886
22887#[inline]
22891#[target_feature(enable = "avx512f,avx512vl")]
22892#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22893#[cfg_attr(test, assert_instr(vshufps, MASK = 0b11_00_01_11))]
22894#[rustc_legacy_const_generics(3)]
22895#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22896pub const fn _mm256_mask_permute_ps<const MASK: i32>(
22897 src: __m256,
22898 k: __mmask8,
22899 a: __m256,
22900) -> __m256 {
22901 unsafe {
22902 let r = _mm256_permute_ps::<MASK>(a);
22903 transmute(simd_select_bitmask(k, r.as_f32x8(), src.as_f32x8()))
22904 }
22905}
22906
22907#[inline]
22911#[target_feature(enable = "avx512f,avx512vl")]
22912#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22913#[cfg_attr(test, assert_instr(vshufps, MASK = 0b11_00_01_11))]
22914#[rustc_legacy_const_generics(2)]
22915#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22916pub const fn _mm256_maskz_permute_ps<const MASK: i32>(k: __mmask8, a: __m256) -> __m256 {
22917 unsafe {
22918 let r = _mm256_permute_ps::<MASK>(a);
22919 transmute(simd_select_bitmask(k, r.as_f32x8(), f32x8::ZERO))
22920 }
22921}
22922
22923#[inline]
22927#[target_feature(enable = "avx512f,avx512vl")]
22928#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22929#[cfg_attr(test, assert_instr(vshufps, MASK = 0b11_00_01_11))]
22930#[rustc_legacy_const_generics(3)]
22931#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22932pub const fn _mm_mask_permute_ps<const MASK: i32>(src: __m128, k: __mmask8, a: __m128) -> __m128 {
22933 unsafe {
22934 let r = _mm_permute_ps::<MASK>(a);
22935 transmute(simd_select_bitmask(k, r.as_f32x4(), src.as_f32x4()))
22936 }
22937}
22938
22939#[inline]
22943#[target_feature(enable = "avx512f,avx512vl")]
22944#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22945#[cfg_attr(test, assert_instr(vshufps, MASK = 0b11_00_01_11))]
22946#[rustc_legacy_const_generics(2)]
22947#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22948pub const fn _mm_maskz_permute_ps<const MASK: i32>(k: __mmask8, a: __m128) -> __m128 {
22949 unsafe {
22950 let r = _mm_permute_ps::<MASK>(a);
22951 transmute(simd_select_bitmask(k, r.as_f32x4(), f32x4::ZERO))
22952 }
22953}
22954
22955#[inline]
22959#[target_feature(enable = "avx512f")]
22960#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22961#[cfg_attr(test, assert_instr(vshufpd, MASK = 0b11_01_10_01))]
22962#[rustc_legacy_const_generics(1)]
22963#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22964pub const fn _mm512_permute_pd<const MASK: i32>(a: __m512d) -> __m512d {
22965 unsafe {
22966 static_assert_uimm_bits!(MASK, 8);
22967 simd_shuffle!(
22968 a,
22969 a,
22970 [
22971 MASK as u32 & 0b1,
22972 ((MASK as u32 >> 1) & 0b1),
22973 ((MASK as u32 >> 2) & 0b1) + 2,
22974 ((MASK as u32 >> 3) & 0b1) + 2,
22975 ((MASK as u32 >> 4) & 0b1) + 4,
22976 ((MASK as u32 >> 5) & 0b1) + 4,
22977 ((MASK as u32 >> 6) & 0b1) + 6,
22978 ((MASK as u32 >> 7) & 0b1) + 6,
22979 ],
22980 )
22981 }
22982}
22983
22984#[inline]
22988#[target_feature(enable = "avx512f")]
22989#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
22990#[cfg_attr(test, assert_instr(vshufpd, MASK = 0b11_01_10_01))]
22991#[rustc_legacy_const_generics(3)]
22992#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
22993pub const fn _mm512_mask_permute_pd<const MASK: i32>(
22994 src: __m512d,
22995 k: __mmask8,
22996 a: __m512d,
22997) -> __m512d {
22998 unsafe {
22999 static_assert_uimm_bits!(MASK, 8);
23000 let r = _mm512_permute_pd::<MASK>(a);
23001 transmute(simd_select_bitmask(k, r.as_f64x8(), src.as_f64x8()))
23002 }
23003}
23004
23005#[inline]
23009#[target_feature(enable = "avx512f")]
23010#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23011#[cfg_attr(test, assert_instr(vshufpd, MASK = 0b11_01_10_01))]
23012#[rustc_legacy_const_generics(2)]
23013#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23014pub const fn _mm512_maskz_permute_pd<const MASK: i32>(k: __mmask8, a: __m512d) -> __m512d {
23015 unsafe {
23016 static_assert_uimm_bits!(MASK, 8);
23017 let r = _mm512_permute_pd::<MASK>(a);
23018 transmute(simd_select_bitmask(k, r.as_f64x8(), f64x8::ZERO))
23019 }
23020}
23021
23022#[inline]
23026#[target_feature(enable = "avx512f,avx512vl")]
23027#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23028#[cfg_attr(test, assert_instr(vshufpd, MASK = 0b11_01))]
23029#[rustc_legacy_const_generics(3)]
23030#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23031pub const fn _mm256_mask_permute_pd<const MASK: i32>(
23032 src: __m256d,
23033 k: __mmask8,
23034 a: __m256d,
23035) -> __m256d {
23036 unsafe {
23037 static_assert_uimm_bits!(MASK, 4);
23038 let r = _mm256_permute_pd::<MASK>(a);
23039 transmute(simd_select_bitmask(k, r.as_f64x4(), src.as_f64x4()))
23040 }
23041}
23042
23043#[inline]
23047#[target_feature(enable = "avx512f,avx512vl")]
23048#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23049#[cfg_attr(test, assert_instr(vshufpd, MASK = 0b11_01))]
23050#[rustc_legacy_const_generics(2)]
23051#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23052pub const fn _mm256_maskz_permute_pd<const MASK: i32>(k: __mmask8, a: __m256d) -> __m256d {
23053 unsafe {
23054 static_assert_uimm_bits!(MASK, 4);
23055 let r = _mm256_permute_pd::<MASK>(a);
23056 transmute(simd_select_bitmask(k, r.as_f64x4(), f64x4::ZERO))
23057 }
23058}
23059
23060#[inline]
23064#[target_feature(enable = "avx512f,avx512vl")]
23065#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23066#[cfg_attr(test, assert_instr(vshufpd, IMM2 = 0b01))]
23067#[rustc_legacy_const_generics(3)]
23068#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23069pub const fn _mm_mask_permute_pd<const IMM2: i32>(
23070 src: __m128d,
23071 k: __mmask8,
23072 a: __m128d,
23073) -> __m128d {
23074 unsafe {
23075 static_assert_uimm_bits!(IMM2, 2);
23076 let r = _mm_permute_pd::<IMM2>(a);
23077 transmute(simd_select_bitmask(k, r.as_f64x2(), src.as_f64x2()))
23078 }
23079}
23080
23081#[inline]
23085#[target_feature(enable = "avx512f,avx512vl")]
23086#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23087#[cfg_attr(test, assert_instr(vshufpd, IMM2 = 0b01))]
23088#[rustc_legacy_const_generics(2)]
23089#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23090pub const fn _mm_maskz_permute_pd<const IMM2: i32>(k: __mmask8, a: __m128d) -> __m128d {
23091 unsafe {
23092 static_assert_uimm_bits!(IMM2, 2);
23093 let r = _mm_permute_pd::<IMM2>(a);
23094 transmute(simd_select_bitmask(k, r.as_f64x2(), f64x2::ZERO))
23095 }
23096}
23097
23098#[inline]
23102#[target_feature(enable = "avx512f")]
23103#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23104#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(1)]
23106#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23107pub const fn _mm512_permutex_epi64<const MASK: i32>(a: __m512i) -> __m512i {
23108 unsafe {
23109 static_assert_uimm_bits!(MASK, 8);
23110 simd_shuffle!(
23111 a,
23112 a,
23113 [
23114 MASK as u32 & 0b11,
23115 (MASK as u32 >> 2) & 0b11,
23116 ((MASK as u32 >> 4) & 0b11),
23117 ((MASK as u32 >> 6) & 0b11),
23118 (MASK as u32 & 0b11) + 4,
23119 ((MASK as u32 >> 2) & 0b11) + 4,
23120 ((MASK as u32 >> 4) & 0b11) + 4,
23121 ((MASK as u32 >> 6) & 0b11) + 4,
23122 ],
23123 )
23124 }
23125}
23126
23127#[inline]
23131#[target_feature(enable = "avx512f")]
23132#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23133#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(3)]
23135#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23136pub const fn _mm512_mask_permutex_epi64<const MASK: i32>(
23137 src: __m512i,
23138 k: __mmask8,
23139 a: __m512i,
23140) -> __m512i {
23141 unsafe {
23142 static_assert_uimm_bits!(MASK, 8);
23143 let r = _mm512_permutex_epi64::<MASK>(a);
23144 transmute(simd_select_bitmask(k, r.as_i64x8(), src.as_i64x8()))
23145 }
23146}
23147
23148#[inline]
23152#[target_feature(enable = "avx512f")]
23153#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23154#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(2)]
23156#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23157pub const fn _mm512_maskz_permutex_epi64<const MASK: i32>(k: __mmask8, a: __m512i) -> __m512i {
23158 unsafe {
23159 static_assert_uimm_bits!(MASK, 8);
23160 let r = _mm512_permutex_epi64::<MASK>(a);
23161 transmute(simd_select_bitmask(k, r.as_i64x8(), i64x8::ZERO))
23162 }
23163}
23164
23165#[inline]
23169#[target_feature(enable = "avx512f,avx512vl")]
23170#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23171#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(1)]
23173#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23174pub const fn _mm256_permutex_epi64<const MASK: i32>(a: __m256i) -> __m256i {
23175 unsafe {
23176 static_assert_uimm_bits!(MASK, 8);
23177 simd_shuffle!(
23178 a,
23179 a,
23180 [
23181 MASK as u32 & 0b11,
23182 (MASK as u32 >> 2) & 0b11,
23183 ((MASK as u32 >> 4) & 0b11),
23184 ((MASK as u32 >> 6) & 0b11),
23185 ],
23186 )
23187 }
23188}
23189
23190#[inline]
23194#[target_feature(enable = "avx512f,avx512vl")]
23195#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23196#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(3)]
23198#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23199pub const fn _mm256_mask_permutex_epi64<const MASK: i32>(
23200 src: __m256i,
23201 k: __mmask8,
23202 a: __m256i,
23203) -> __m256i {
23204 unsafe {
23205 static_assert_uimm_bits!(MASK, 8);
23206 let r = _mm256_permutex_epi64::<MASK>(a);
23207 transmute(simd_select_bitmask(k, r.as_i64x4(), src.as_i64x4()))
23208 }
23209}
23210
23211#[inline]
23215#[target_feature(enable = "avx512f,avx512vl")]
23216#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23217#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(2)]
23219#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23220pub const fn _mm256_maskz_permutex_epi64<const MASK: i32>(k: __mmask8, a: __m256i) -> __m256i {
23221 unsafe {
23222 static_assert_uimm_bits!(MASK, 8);
23223 let r = _mm256_permutex_epi64::<MASK>(a);
23224 transmute(simd_select_bitmask(k, r.as_i64x4(), i64x4::ZERO))
23225 }
23226}
23227
23228#[inline]
23232#[target_feature(enable = "avx512f")]
23233#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23234#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(1)]
23236#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23237pub const fn _mm512_permutex_pd<const MASK: i32>(a: __m512d) -> __m512d {
23238 unsafe {
23239 static_assert_uimm_bits!(MASK, 8);
23240 simd_shuffle!(
23241 a,
23242 a,
23243 [
23244 MASK as u32 & 0b11,
23245 (MASK as u32 >> 2) & 0b11,
23246 ((MASK as u32 >> 4) & 0b11),
23247 ((MASK as u32 >> 6) & 0b11),
23248 (MASK as u32 & 0b11) + 4,
23249 ((MASK as u32 >> 2) & 0b11) + 4,
23250 ((MASK as u32 >> 4) & 0b11) + 4,
23251 ((MASK as u32 >> 6) & 0b11) + 4,
23252 ],
23253 )
23254 }
23255}
23256
23257#[inline]
23261#[target_feature(enable = "avx512f")]
23262#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23263#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(3)]
23265#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23266pub const fn _mm512_mask_permutex_pd<const MASK: i32>(
23267 src: __m512d,
23268 k: __mmask8,
23269 a: __m512d,
23270) -> __m512d {
23271 unsafe {
23272 let r = _mm512_permutex_pd::<MASK>(a);
23273 transmute(simd_select_bitmask(k, r.as_f64x8(), src.as_f64x8()))
23274 }
23275}
23276
23277#[inline]
23281#[target_feature(enable = "avx512f")]
23282#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23283#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(2)]
23285#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23286pub const fn _mm512_maskz_permutex_pd<const MASK: i32>(k: __mmask8, a: __m512d) -> __m512d {
23287 unsafe {
23288 let r = _mm512_permutex_pd::<MASK>(a);
23289 transmute(simd_select_bitmask(k, r.as_f64x8(), f64x8::ZERO))
23290 }
23291}
23292
23293#[inline]
23297#[target_feature(enable = "avx512f,avx512vl")]
23298#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23299#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(1)]
23301#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23302pub const fn _mm256_permutex_pd<const MASK: i32>(a: __m256d) -> __m256d {
23303 unsafe {
23304 static_assert_uimm_bits!(MASK, 8);
23305 simd_shuffle!(
23306 a,
23307 a,
23308 [
23309 MASK as u32 & 0b11,
23310 (MASK as u32 >> 2) & 0b11,
23311 ((MASK as u32 >> 4) & 0b11),
23312 ((MASK as u32 >> 6) & 0b11),
23313 ],
23314 )
23315 }
23316}
23317
23318#[inline]
23322#[target_feature(enable = "avx512f,avx512vl")]
23323#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23324#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(3)]
23326#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23327pub const fn _mm256_mask_permutex_pd<const MASK: i32>(
23328 src: __m256d,
23329 k: __mmask8,
23330 a: __m256d,
23331) -> __m256d {
23332 unsafe {
23333 static_assert_uimm_bits!(MASK, 8);
23334 let r = _mm256_permutex_pd::<MASK>(a);
23335 transmute(simd_select_bitmask(k, r.as_f64x4(), src.as_f64x4()))
23336 }
23337}
23338
23339#[inline]
23343#[target_feature(enable = "avx512f,avx512vl")]
23344#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23345#[cfg_attr(test, assert_instr(vperm, MASK = 0b10_01_10_11))] #[rustc_legacy_const_generics(2)]
23347#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
23348pub const fn _mm256_maskz_permutex_pd<const MASK: i32>(k: __mmask8, a: __m256d) -> __m256d {
23349 unsafe {
23350 static_assert_uimm_bits!(MASK, 8);
23351 let r = _mm256_permutex_pd::<MASK>(a);
23352 transmute(simd_select_bitmask(k, r.as_f64x4(), f64x4::ZERO))
23353 }
23354}
23355
23356#[inline]
23360#[target_feature(enable = "avx512f")]
23361#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23362#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_permutevar_epi32(idx: __m512i, a: __m512i) -> __m512i {
23364 unsafe { transmute(vpermd(a.as_i32x16(), idx.as_i32x16())) }
23365}
23366
23367#[inline]
23371#[target_feature(enable = "avx512f")]
23372#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23373#[cfg_attr(test, assert_instr(vpermd))]
23374pub fn _mm512_mask_permutevar_epi32(
23375 src: __m512i,
23376 k: __mmask16,
23377 idx: __m512i,
23378 a: __m512i,
23379) -> __m512i {
23380 unsafe {
23381 let permute = _mm512_permutevar_epi32(idx, a).as_i32x16();
23382 transmute(simd_select_bitmask(k, permute, src.as_i32x16()))
23383 }
23384}
23385
23386#[inline]
23390#[target_feature(enable = "avx512f")]
23391#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23392#[cfg_attr(test, assert_instr(vpermilps))]
23393pub fn _mm512_permutevar_ps(a: __m512, b: __m512i) -> __m512 {
23394 unsafe { transmute(vpermilps(a.as_f32x16(), b.as_i32x16())) }
23395}
23396
23397#[inline]
23401#[target_feature(enable = "avx512f")]
23402#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23403#[cfg_attr(test, assert_instr(vpermilps))]
23404pub fn _mm512_mask_permutevar_ps(src: __m512, k: __mmask16, a: __m512, b: __m512i) -> __m512 {
23405 unsafe {
23406 let permute = _mm512_permutevar_ps(a, b).as_f32x16();
23407 transmute(simd_select_bitmask(k, permute, src.as_f32x16()))
23408 }
23409}
23410
23411#[inline]
23415#[target_feature(enable = "avx512f")]
23416#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23417#[cfg_attr(test, assert_instr(vpermilps))]
23418pub fn _mm512_maskz_permutevar_ps(k: __mmask16, a: __m512, b: __m512i) -> __m512 {
23419 unsafe {
23420 let permute = _mm512_permutevar_ps(a, b).as_f32x16();
23421 transmute(simd_select_bitmask(k, permute, f32x16::ZERO))
23422 }
23423}
23424
23425#[inline]
23429#[target_feature(enable = "avx512f,avx512vl")]
23430#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23431#[cfg_attr(test, assert_instr(vpermilps))]
23432pub fn _mm256_mask_permutevar_ps(src: __m256, k: __mmask8, a: __m256, b: __m256i) -> __m256 {
23433 unsafe {
23434 let permute = _mm256_permutevar_ps(a, b).as_f32x8();
23435 transmute(simd_select_bitmask(k, permute, src.as_f32x8()))
23436 }
23437}
23438
23439#[inline]
23443#[target_feature(enable = "avx512f,avx512vl")]
23444#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23445#[cfg_attr(test, assert_instr(vpermilps))]
23446pub fn _mm256_maskz_permutevar_ps(k: __mmask8, a: __m256, b: __m256i) -> __m256 {
23447 unsafe {
23448 let permute = _mm256_permutevar_ps(a, b).as_f32x8();
23449 transmute(simd_select_bitmask(k, permute, f32x8::ZERO))
23450 }
23451}
23452
23453#[inline]
23457#[target_feature(enable = "avx512f,avx512vl")]
23458#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23459#[cfg_attr(test, assert_instr(vpermilps))]
23460pub fn _mm_mask_permutevar_ps(src: __m128, k: __mmask8, a: __m128, b: __m128i) -> __m128 {
23461 unsafe {
23462 let permute = _mm_permutevar_ps(a, b).as_f32x4();
23463 transmute(simd_select_bitmask(k, permute, src.as_f32x4()))
23464 }
23465}
23466
23467#[inline]
23471#[target_feature(enable = "avx512f,avx512vl")]
23472#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23473#[cfg_attr(test, assert_instr(vpermilps))]
23474pub fn _mm_maskz_permutevar_ps(k: __mmask8, a: __m128, b: __m128i) -> __m128 {
23475 unsafe {
23476 let permute = _mm_permutevar_ps(a, b).as_f32x4();
23477 transmute(simd_select_bitmask(k, permute, f32x4::ZERO))
23478 }
23479}
23480
23481#[inline]
23485#[target_feature(enable = "avx512f")]
23486#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23487#[cfg_attr(test, assert_instr(vpermilpd))]
23488pub fn _mm512_permutevar_pd(a: __m512d, b: __m512i) -> __m512d {
23489 unsafe { transmute(vpermilpd(a.as_f64x8(), b.as_i64x8())) }
23490}
23491
23492#[inline]
23496#[target_feature(enable = "avx512f")]
23497#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23498#[cfg_attr(test, assert_instr(vpermilpd))]
23499pub fn _mm512_mask_permutevar_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512i) -> __m512d {
23500 unsafe {
23501 let permute = _mm512_permutevar_pd(a, b).as_f64x8();
23502 transmute(simd_select_bitmask(k, permute, src.as_f64x8()))
23503 }
23504}
23505
23506#[inline]
23510#[target_feature(enable = "avx512f")]
23511#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23512#[cfg_attr(test, assert_instr(vpermilpd))]
23513pub fn _mm512_maskz_permutevar_pd(k: __mmask8, a: __m512d, b: __m512i) -> __m512d {
23514 unsafe {
23515 let permute = _mm512_permutevar_pd(a, b).as_f64x8();
23516 transmute(simd_select_bitmask(k, permute, f64x8::ZERO))
23517 }
23518}
23519
23520#[inline]
23524#[target_feature(enable = "avx512f,avx512vl")]
23525#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23526#[cfg_attr(test, assert_instr(vpermilpd))]
23527pub fn _mm256_mask_permutevar_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256i) -> __m256d {
23528 unsafe {
23529 let permute = _mm256_permutevar_pd(a, b).as_f64x4();
23530 transmute(simd_select_bitmask(k, permute, src.as_f64x4()))
23531 }
23532}
23533
23534#[inline]
23538#[target_feature(enable = "avx512f,avx512vl")]
23539#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23540#[cfg_attr(test, assert_instr(vpermilpd))]
23541pub fn _mm256_maskz_permutevar_pd(k: __mmask8, a: __m256d, b: __m256i) -> __m256d {
23542 unsafe {
23543 let permute = _mm256_permutevar_pd(a, b).as_f64x4();
23544 transmute(simd_select_bitmask(k, permute, f64x4::ZERO))
23545 }
23546}
23547
23548#[inline]
23552#[target_feature(enable = "avx512f,avx512vl")]
23553#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23554#[cfg_attr(test, assert_instr(vpermilpd))]
23555pub fn _mm_mask_permutevar_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128i) -> __m128d {
23556 unsafe {
23557 let permute = _mm_permutevar_pd(a, b).as_f64x2();
23558 transmute(simd_select_bitmask(k, permute, src.as_f64x2()))
23559 }
23560}
23561
23562#[inline]
23566#[target_feature(enable = "avx512f,avx512vl")]
23567#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23568#[cfg_attr(test, assert_instr(vpermilpd))]
23569pub fn _mm_maskz_permutevar_pd(k: __mmask8, a: __m128d, b: __m128i) -> __m128d {
23570 unsafe {
23571 let permute = _mm_permutevar_pd(a, b).as_f64x2();
23572 transmute(simd_select_bitmask(k, permute, f64x2::ZERO))
23573 }
23574}
23575
23576#[inline]
23580#[target_feature(enable = "avx512f")]
23581#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23582#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_permutexvar_epi32(idx: __m512i, a: __m512i) -> __m512i {
23584 unsafe { transmute(vpermd(a.as_i32x16(), idx.as_i32x16())) }
23585}
23586
23587#[inline]
23591#[target_feature(enable = "avx512f")]
23592#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23593#[cfg_attr(test, assert_instr(vpermd))]
23594pub fn _mm512_mask_permutexvar_epi32(
23595 src: __m512i,
23596 k: __mmask16,
23597 idx: __m512i,
23598 a: __m512i,
23599) -> __m512i {
23600 unsafe {
23601 let permute = _mm512_permutexvar_epi32(idx, a).as_i32x16();
23602 transmute(simd_select_bitmask(k, permute, src.as_i32x16()))
23603 }
23604}
23605
23606#[inline]
23610#[target_feature(enable = "avx512f")]
23611#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23612#[cfg_attr(test, assert_instr(vpermd))]
23613pub fn _mm512_maskz_permutexvar_epi32(k: __mmask16, idx: __m512i, a: __m512i) -> __m512i {
23614 unsafe {
23615 let permute = _mm512_permutexvar_epi32(idx, a).as_i32x16();
23616 transmute(simd_select_bitmask(k, permute, i32x16::ZERO))
23617 }
23618}
23619
23620#[inline]
23624#[target_feature(enable = "avx512f,avx512vl")]
23625#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23626#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_permutexvar_epi32(idx: __m256i, a: __m256i) -> __m256i {
23628 _mm256_permutevar8x32_epi32(a, idx) }
23630
23631#[inline]
23635#[target_feature(enable = "avx512f,avx512vl")]
23636#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23637#[cfg_attr(test, assert_instr(vpermd))]
23638pub fn _mm256_mask_permutexvar_epi32(
23639 src: __m256i,
23640 k: __mmask8,
23641 idx: __m256i,
23642 a: __m256i,
23643) -> __m256i {
23644 unsafe {
23645 let permute = _mm256_permutexvar_epi32(idx, a).as_i32x8();
23646 transmute(simd_select_bitmask(k, permute, src.as_i32x8()))
23647 }
23648}
23649
23650#[inline]
23654#[target_feature(enable = "avx512f,avx512vl")]
23655#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23656#[cfg_attr(test, assert_instr(vpermd))]
23657pub fn _mm256_maskz_permutexvar_epi32(k: __mmask8, idx: __m256i, a: __m256i) -> __m256i {
23658 unsafe {
23659 let permute = _mm256_permutexvar_epi32(idx, a).as_i32x8();
23660 transmute(simd_select_bitmask(k, permute, i32x8::ZERO))
23661 }
23662}
23663
23664#[inline]
23668#[target_feature(enable = "avx512f")]
23669#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23670#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_permutexvar_epi64(idx: __m512i, a: __m512i) -> __m512i {
23672 unsafe { transmute(vpermq(a.as_i64x8(), idx.as_i64x8())) }
23673}
23674
23675#[inline]
23679#[target_feature(enable = "avx512f")]
23680#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23681#[cfg_attr(test, assert_instr(vpermq))]
23682pub fn _mm512_mask_permutexvar_epi64(
23683 src: __m512i,
23684 k: __mmask8,
23685 idx: __m512i,
23686 a: __m512i,
23687) -> __m512i {
23688 unsafe {
23689 let permute = _mm512_permutexvar_epi64(idx, a).as_i64x8();
23690 transmute(simd_select_bitmask(k, permute, src.as_i64x8()))
23691 }
23692}
23693
23694#[inline]
23698#[target_feature(enable = "avx512f")]
23699#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23700#[cfg_attr(test, assert_instr(vpermq))]
23701pub fn _mm512_maskz_permutexvar_epi64(k: __mmask8, idx: __m512i, a: __m512i) -> __m512i {
23702 unsafe {
23703 let permute = _mm512_permutexvar_epi64(idx, a).as_i64x8();
23704 transmute(simd_select_bitmask(k, permute, i64x8::ZERO))
23705 }
23706}
23707
23708#[inline]
23712#[target_feature(enable = "avx512f,avx512vl")]
23713#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23714#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_permutexvar_epi64(idx: __m256i, a: __m256i) -> __m256i {
23716 unsafe { transmute(vpermq256(a.as_i64x4(), idx.as_i64x4())) }
23717}
23718
23719#[inline]
23723#[target_feature(enable = "avx512f,avx512vl")]
23724#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23725#[cfg_attr(test, assert_instr(vpermq))]
23726pub fn _mm256_mask_permutexvar_epi64(
23727 src: __m256i,
23728 k: __mmask8,
23729 idx: __m256i,
23730 a: __m256i,
23731) -> __m256i {
23732 unsafe {
23733 let permute = _mm256_permutexvar_epi64(idx, a).as_i64x4();
23734 transmute(simd_select_bitmask(k, permute, src.as_i64x4()))
23735 }
23736}
23737
23738#[inline]
23742#[target_feature(enable = "avx512f,avx512vl")]
23743#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23744#[cfg_attr(test, assert_instr(vpermq))]
23745pub fn _mm256_maskz_permutexvar_epi64(k: __mmask8, idx: __m256i, a: __m256i) -> __m256i {
23746 unsafe {
23747 let permute = _mm256_permutexvar_epi64(idx, a).as_i64x4();
23748 transmute(simd_select_bitmask(k, permute, i64x4::ZERO))
23749 }
23750}
23751
23752#[inline]
23756#[target_feature(enable = "avx512f")]
23757#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23758#[cfg_attr(test, assert_instr(vpermps))]
23759pub fn _mm512_permutexvar_ps(idx: __m512i, a: __m512) -> __m512 {
23760 unsafe { transmute(vpermps(a.as_f32x16(), idx.as_i32x16())) }
23761}
23762
23763#[inline]
23767#[target_feature(enable = "avx512f")]
23768#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23769#[cfg_attr(test, assert_instr(vpermps))]
23770pub fn _mm512_mask_permutexvar_ps(src: __m512, k: __mmask16, idx: __m512i, a: __m512) -> __m512 {
23771 unsafe {
23772 let permute = _mm512_permutexvar_ps(idx, a).as_f32x16();
23773 transmute(simd_select_bitmask(k, permute, src.as_f32x16()))
23774 }
23775}
23776
23777#[inline]
23781#[target_feature(enable = "avx512f")]
23782#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23783#[cfg_attr(test, assert_instr(vpermps))]
23784pub fn _mm512_maskz_permutexvar_ps(k: __mmask16, idx: __m512i, a: __m512) -> __m512 {
23785 unsafe {
23786 let permute = _mm512_permutexvar_ps(idx, a).as_f32x16();
23787 transmute(simd_select_bitmask(k, permute, f32x16::ZERO))
23788 }
23789}
23790
23791#[inline]
23795#[target_feature(enable = "avx512f,avx512vl")]
23796#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23797#[cfg_attr(test, assert_instr(vpermps))]
23798pub fn _mm256_permutexvar_ps(idx: __m256i, a: __m256) -> __m256 {
23799 _mm256_permutevar8x32_ps(a, idx) }
23801
23802#[inline]
23806#[target_feature(enable = "avx512f,avx512vl")]
23807#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23808#[cfg_attr(test, assert_instr(vpermps))]
23809pub fn _mm256_mask_permutexvar_ps(src: __m256, k: __mmask8, idx: __m256i, a: __m256) -> __m256 {
23810 unsafe {
23811 let permute = _mm256_permutexvar_ps(idx, a).as_f32x8();
23812 transmute(simd_select_bitmask(k, permute, src.as_f32x8()))
23813 }
23814}
23815
23816#[inline]
23820#[target_feature(enable = "avx512f,avx512vl")]
23821#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23822#[cfg_attr(test, assert_instr(vpermps))]
23823pub fn _mm256_maskz_permutexvar_ps(k: __mmask8, idx: __m256i, a: __m256) -> __m256 {
23824 unsafe {
23825 let permute = _mm256_permutexvar_ps(idx, a).as_f32x8();
23826 transmute(simd_select_bitmask(k, permute, f32x8::ZERO))
23827 }
23828}
23829
23830#[inline]
23834#[target_feature(enable = "avx512f")]
23835#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23836#[cfg_attr(test, assert_instr(vpermpd))]
23837pub fn _mm512_permutexvar_pd(idx: __m512i, a: __m512d) -> __m512d {
23838 unsafe { transmute(vpermpd(a.as_f64x8(), idx.as_i64x8())) }
23839}
23840
23841#[inline]
23845#[target_feature(enable = "avx512f")]
23846#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23847#[cfg_attr(test, assert_instr(vpermpd))]
23848pub fn _mm512_mask_permutexvar_pd(src: __m512d, k: __mmask8, idx: __m512i, a: __m512d) -> __m512d {
23849 unsafe {
23850 let permute = _mm512_permutexvar_pd(idx, a).as_f64x8();
23851 transmute(simd_select_bitmask(k, permute, src.as_f64x8()))
23852 }
23853}
23854
23855#[inline]
23859#[target_feature(enable = "avx512f")]
23860#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23861#[cfg_attr(test, assert_instr(vpermpd))]
23862pub fn _mm512_maskz_permutexvar_pd(k: __mmask8, idx: __m512i, a: __m512d) -> __m512d {
23863 unsafe {
23864 let permute = _mm512_permutexvar_pd(idx, a).as_f64x8();
23865 transmute(simd_select_bitmask(k, permute, f64x8::ZERO))
23866 }
23867}
23868
23869#[inline]
23873#[target_feature(enable = "avx512f,avx512vl")]
23874#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23875#[cfg_attr(test, assert_instr(vpermpd))]
23876pub fn _mm256_permutexvar_pd(idx: __m256i, a: __m256d) -> __m256d {
23877 unsafe { transmute(vpermpd256(a.as_f64x4(), idx.as_i64x4())) }
23878}
23879
23880#[inline]
23884#[target_feature(enable = "avx512f,avx512vl")]
23885#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23886#[cfg_attr(test, assert_instr(vpermpd))]
23887pub fn _mm256_mask_permutexvar_pd(src: __m256d, k: __mmask8, idx: __m256i, a: __m256d) -> __m256d {
23888 unsafe {
23889 let permute = _mm256_permutexvar_pd(idx, a).as_f64x4();
23890 transmute(simd_select_bitmask(k, permute, src.as_f64x4()))
23891 }
23892}
23893
23894#[inline]
23898#[target_feature(enable = "avx512f,avx512vl")]
23899#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23900#[cfg_attr(test, assert_instr(vpermpd))]
23901pub fn _mm256_maskz_permutexvar_pd(k: __mmask8, idx: __m256i, a: __m256d) -> __m256d {
23902 unsafe {
23903 let permute = _mm256_permutexvar_pd(idx, a).as_f64x4();
23904 transmute(simd_select_bitmask(k, permute, f64x4::ZERO))
23905 }
23906}
23907
23908#[inline]
23912#[target_feature(enable = "avx512f")]
23913#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23914#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_permutex2var_epi32(a: __m512i, idx: __m512i, b: __m512i) -> __m512i {
23916 unsafe { transmute(vpermi2d(a.as_i32x16(), idx.as_i32x16(), b.as_i32x16())) }
23917}
23918
23919#[inline]
23923#[target_feature(enable = "avx512f")]
23924#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23925#[cfg_attr(test, assert_instr(vpermt2d))]
23926pub fn _mm512_mask_permutex2var_epi32(
23927 a: __m512i,
23928 k: __mmask16,
23929 idx: __m512i,
23930 b: __m512i,
23931) -> __m512i {
23932 unsafe {
23933 let permute = _mm512_permutex2var_epi32(a, idx, b).as_i32x16();
23934 transmute(simd_select_bitmask(k, permute, a.as_i32x16()))
23935 }
23936}
23937
23938#[inline]
23942#[target_feature(enable = "avx512f")]
23943#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23944#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_maskz_permutex2var_epi32(
23946 k: __mmask16,
23947 a: __m512i,
23948 idx: __m512i,
23949 b: __m512i,
23950) -> __m512i {
23951 unsafe {
23952 let permute = _mm512_permutex2var_epi32(a, idx, b).as_i32x16();
23953 transmute(simd_select_bitmask(k, permute, i32x16::ZERO))
23954 }
23955}
23956
23957#[inline]
23961#[target_feature(enable = "avx512f")]
23962#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23963#[cfg_attr(test, assert_instr(vpermi2d))]
23964pub fn _mm512_mask2_permutex2var_epi32(
23965 a: __m512i,
23966 idx: __m512i,
23967 k: __mmask16,
23968 b: __m512i,
23969) -> __m512i {
23970 unsafe {
23971 let permute = _mm512_permutex2var_epi32(a, idx, b).as_i32x16();
23972 transmute(simd_select_bitmask(k, permute, idx.as_i32x16()))
23973 }
23974}
23975
23976#[inline]
23980#[target_feature(enable = "avx512f,avx512vl")]
23981#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23982#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_permutex2var_epi32(a: __m256i, idx: __m256i, b: __m256i) -> __m256i {
23984 unsafe { transmute(vpermi2d256(a.as_i32x8(), idx.as_i32x8(), b.as_i32x8())) }
23985}
23986
23987#[inline]
23991#[target_feature(enable = "avx512f,avx512vl")]
23992#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
23993#[cfg_attr(test, assert_instr(vpermt2d))]
23994pub fn _mm256_mask_permutex2var_epi32(
23995 a: __m256i,
23996 k: __mmask8,
23997 idx: __m256i,
23998 b: __m256i,
23999) -> __m256i {
24000 unsafe {
24001 let permute = _mm256_permutex2var_epi32(a, idx, b).as_i32x8();
24002 transmute(simd_select_bitmask(k, permute, a.as_i32x8()))
24003 }
24004}
24005
24006#[inline]
24010#[target_feature(enable = "avx512f,avx512vl")]
24011#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24012#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_maskz_permutex2var_epi32(
24014 k: __mmask8,
24015 a: __m256i,
24016 idx: __m256i,
24017 b: __m256i,
24018) -> __m256i {
24019 unsafe {
24020 let permute = _mm256_permutex2var_epi32(a, idx, b).as_i32x8();
24021 transmute(simd_select_bitmask(k, permute, i32x8::ZERO))
24022 }
24023}
24024
24025#[inline]
24029#[target_feature(enable = "avx512f,avx512vl")]
24030#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24031#[cfg_attr(test, assert_instr(vpermi2d))]
24032pub fn _mm256_mask2_permutex2var_epi32(
24033 a: __m256i,
24034 idx: __m256i,
24035 k: __mmask8,
24036 b: __m256i,
24037) -> __m256i {
24038 unsafe {
24039 let permute = _mm256_permutex2var_epi32(a, idx, b).as_i32x8();
24040 transmute(simd_select_bitmask(k, permute, idx.as_i32x8()))
24041 }
24042}
24043
24044#[inline]
24048#[target_feature(enable = "avx512f,avx512vl")]
24049#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24050#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_permutex2var_epi32(a: __m128i, idx: __m128i, b: __m128i) -> __m128i {
24052 unsafe { transmute(vpermi2d128(a.as_i32x4(), idx.as_i32x4(), b.as_i32x4())) }
24053}
24054
24055#[inline]
24059#[target_feature(enable = "avx512f,avx512vl")]
24060#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24061#[cfg_attr(test, assert_instr(vpermt2d))]
24062pub fn _mm_mask_permutex2var_epi32(a: __m128i, k: __mmask8, idx: __m128i, b: __m128i) -> __m128i {
24063 unsafe {
24064 let permute = _mm_permutex2var_epi32(a, idx, b).as_i32x4();
24065 transmute(simd_select_bitmask(k, permute, a.as_i32x4()))
24066 }
24067}
24068
24069#[inline]
24073#[target_feature(enable = "avx512f,avx512vl")]
24074#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24075#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_maskz_permutex2var_epi32(k: __mmask8, a: __m128i, idx: __m128i, b: __m128i) -> __m128i {
24077 unsafe {
24078 let permute = _mm_permutex2var_epi32(a, idx, b).as_i32x4();
24079 transmute(simd_select_bitmask(k, permute, i32x4::ZERO))
24080 }
24081}
24082
24083#[inline]
24087#[target_feature(enable = "avx512f,avx512vl")]
24088#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24089#[cfg_attr(test, assert_instr(vpermi2d))]
24090pub fn _mm_mask2_permutex2var_epi32(a: __m128i, idx: __m128i, k: __mmask8, b: __m128i) -> __m128i {
24091 unsafe {
24092 let permute = _mm_permutex2var_epi32(a, idx, b).as_i32x4();
24093 transmute(simd_select_bitmask(k, permute, idx.as_i32x4()))
24094 }
24095}
24096
24097#[inline]
24101#[target_feature(enable = "avx512f")]
24102#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24103#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_permutex2var_epi64(a: __m512i, idx: __m512i, b: __m512i) -> __m512i {
24105 unsafe { transmute(vpermi2q(a.as_i64x8(), idx.as_i64x8(), b.as_i64x8())) }
24106}
24107
24108#[inline]
24112#[target_feature(enable = "avx512f")]
24113#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24114#[cfg_attr(test, assert_instr(vpermt2q))]
24115pub fn _mm512_mask_permutex2var_epi64(
24116 a: __m512i,
24117 k: __mmask8,
24118 idx: __m512i,
24119 b: __m512i,
24120) -> __m512i {
24121 unsafe {
24122 let permute = _mm512_permutex2var_epi64(a, idx, b).as_i64x8();
24123 transmute(simd_select_bitmask(k, permute, a.as_i64x8()))
24124 }
24125}
24126
24127#[inline]
24131#[target_feature(enable = "avx512f")]
24132#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24133#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_maskz_permutex2var_epi64(
24135 k: __mmask8,
24136 a: __m512i,
24137 idx: __m512i,
24138 b: __m512i,
24139) -> __m512i {
24140 unsafe {
24141 let permute = _mm512_permutex2var_epi64(a, idx, b).as_i64x8();
24142 transmute(simd_select_bitmask(k, permute, i64x8::ZERO))
24143 }
24144}
24145
24146#[inline]
24150#[target_feature(enable = "avx512f")]
24151#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24152#[cfg_attr(test, assert_instr(vpermi2q))]
24153pub fn _mm512_mask2_permutex2var_epi64(
24154 a: __m512i,
24155 idx: __m512i,
24156 k: __mmask8,
24157 b: __m512i,
24158) -> __m512i {
24159 unsafe {
24160 let permute = _mm512_permutex2var_epi64(a, idx, b).as_i64x8();
24161 transmute(simd_select_bitmask(k, permute, idx.as_i64x8()))
24162 }
24163}
24164
24165#[inline]
24169#[target_feature(enable = "avx512f,avx512vl")]
24170#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24171#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_permutex2var_epi64(a: __m256i, idx: __m256i, b: __m256i) -> __m256i {
24173 unsafe { transmute(vpermi2q256(a.as_i64x4(), idx.as_i64x4(), b.as_i64x4())) }
24174}
24175
24176#[inline]
24180#[target_feature(enable = "avx512f,avx512vl")]
24181#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24182#[cfg_attr(test, assert_instr(vpermt2q))]
24183pub fn _mm256_mask_permutex2var_epi64(
24184 a: __m256i,
24185 k: __mmask8,
24186 idx: __m256i,
24187 b: __m256i,
24188) -> __m256i {
24189 unsafe {
24190 let permute = _mm256_permutex2var_epi64(a, idx, b).as_i64x4();
24191 transmute(simd_select_bitmask(k, permute, a.as_i64x4()))
24192 }
24193}
24194
24195#[inline]
24199#[target_feature(enable = "avx512f,avx512vl")]
24200#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24201#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_maskz_permutex2var_epi64(
24203 k: __mmask8,
24204 a: __m256i,
24205 idx: __m256i,
24206 b: __m256i,
24207) -> __m256i {
24208 unsafe {
24209 let permute = _mm256_permutex2var_epi64(a, idx, b).as_i64x4();
24210 transmute(simd_select_bitmask(k, permute, i64x4::ZERO))
24211 }
24212}
24213
24214#[inline]
24218#[target_feature(enable = "avx512f,avx512vl")]
24219#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24220#[cfg_attr(test, assert_instr(vpermi2q))]
24221pub fn _mm256_mask2_permutex2var_epi64(
24222 a: __m256i,
24223 idx: __m256i,
24224 k: __mmask8,
24225 b: __m256i,
24226) -> __m256i {
24227 unsafe {
24228 let permute = _mm256_permutex2var_epi64(a, idx, b).as_i64x4();
24229 transmute(simd_select_bitmask(k, permute, idx.as_i64x4()))
24230 }
24231}
24232
24233#[inline]
24237#[target_feature(enable = "avx512f,avx512vl")]
24238#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24239#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_permutex2var_epi64(a: __m128i, idx: __m128i, b: __m128i) -> __m128i {
24241 unsafe { transmute(vpermi2q128(a.as_i64x2(), idx.as_i64x2(), b.as_i64x2())) }
24242}
24243
24244#[inline]
24248#[target_feature(enable = "avx512f,avx512vl")]
24249#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24250#[cfg_attr(test, assert_instr(vpermt2q))]
24251pub fn _mm_mask_permutex2var_epi64(a: __m128i, k: __mmask8, idx: __m128i, b: __m128i) -> __m128i {
24252 unsafe {
24253 let permute = _mm_permutex2var_epi64(a, idx, b).as_i64x2();
24254 transmute(simd_select_bitmask(k, permute, a.as_i64x2()))
24255 }
24256}
24257
24258#[inline]
24262#[target_feature(enable = "avx512f,avx512vl")]
24263#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24264#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_maskz_permutex2var_epi64(k: __mmask8, a: __m128i, idx: __m128i, b: __m128i) -> __m128i {
24266 unsafe {
24267 let permute = _mm_permutex2var_epi64(a, idx, b).as_i64x2();
24268 transmute(simd_select_bitmask(k, permute, i64x2::ZERO))
24269 }
24270}
24271
24272#[inline]
24276#[target_feature(enable = "avx512f,avx512vl")]
24277#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24278#[cfg_attr(test, assert_instr(vpermi2q))]
24279pub fn _mm_mask2_permutex2var_epi64(a: __m128i, idx: __m128i, k: __mmask8, b: __m128i) -> __m128i {
24280 unsafe {
24281 let permute = _mm_permutex2var_epi64(a, idx, b).as_i64x2();
24282 transmute(simd_select_bitmask(k, permute, idx.as_i64x2()))
24283 }
24284}
24285
24286#[inline]
24290#[target_feature(enable = "avx512f")]
24291#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24292#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_permutex2var_ps(a: __m512, idx: __m512i, b: __m512) -> __m512 {
24294 unsafe { transmute(vpermi2ps(a.as_f32x16(), idx.as_i32x16(), b.as_f32x16())) }
24295}
24296
24297#[inline]
24301#[target_feature(enable = "avx512f")]
24302#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24303#[cfg_attr(test, assert_instr(vpermt2ps))]
24304pub fn _mm512_mask_permutex2var_ps(a: __m512, k: __mmask16, idx: __m512i, b: __m512) -> __m512 {
24305 unsafe {
24306 let permute = _mm512_permutex2var_ps(a, idx, b).as_f32x16();
24307 transmute(simd_select_bitmask(k, permute, a.as_f32x16()))
24308 }
24309}
24310
24311#[inline]
24315#[target_feature(enable = "avx512f")]
24316#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24317#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_maskz_permutex2var_ps(k: __mmask16, a: __m512, idx: __m512i, b: __m512) -> __m512 {
24319 unsafe {
24320 let permute = _mm512_permutex2var_ps(a, idx, b).as_f32x16();
24321 transmute(simd_select_bitmask(k, permute, f32x16::ZERO))
24322 }
24323}
24324
24325#[inline]
24329#[target_feature(enable = "avx512f")]
24330#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24331#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_mask2_permutex2var_ps(a: __m512, idx: __m512i, k: __mmask16, b: __m512) -> __m512 {
24333 unsafe {
24334 let permute = _mm512_permutex2var_ps(a, idx, b).as_f32x16();
24335 let idx = _mm512_castsi512_ps(idx).as_f32x16();
24336 transmute(simd_select_bitmask(k, permute, idx))
24337 }
24338}
24339
24340#[inline]
24344#[target_feature(enable = "avx512f,avx512vl")]
24345#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24346#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_permutex2var_ps(a: __m256, idx: __m256i, b: __m256) -> __m256 {
24348 unsafe { transmute(vpermi2ps256(a.as_f32x8(), idx.as_i32x8(), b.as_f32x8())) }
24349}
24350
24351#[inline]
24355#[target_feature(enable = "avx512f,avx512vl")]
24356#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24357#[cfg_attr(test, assert_instr(vpermt2ps))]
24358pub fn _mm256_mask_permutex2var_ps(a: __m256, k: __mmask8, idx: __m256i, b: __m256) -> __m256 {
24359 unsafe {
24360 let permute = _mm256_permutex2var_ps(a, idx, b).as_f32x8();
24361 transmute(simd_select_bitmask(k, permute, a.as_f32x8()))
24362 }
24363}
24364
24365#[inline]
24369#[target_feature(enable = "avx512f,avx512vl")]
24370#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24371#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_maskz_permutex2var_ps(k: __mmask8, a: __m256, idx: __m256i, b: __m256) -> __m256 {
24373 unsafe {
24374 let permute = _mm256_permutex2var_ps(a, idx, b).as_f32x8();
24375 transmute(simd_select_bitmask(k, permute, f32x8::ZERO))
24376 }
24377}
24378
24379#[inline]
24383#[target_feature(enable = "avx512f,avx512vl")]
24384#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24385#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_mask2_permutex2var_ps(a: __m256, idx: __m256i, k: __mmask8, b: __m256) -> __m256 {
24387 unsafe {
24388 let permute = _mm256_permutex2var_ps(a, idx, b).as_f32x8();
24389 let idx = _mm256_castsi256_ps(idx).as_f32x8();
24390 transmute(simd_select_bitmask(k, permute, idx))
24391 }
24392}
24393
24394#[inline]
24398#[target_feature(enable = "avx512f,avx512vl")]
24399#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24400#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_permutex2var_ps(a: __m128, idx: __m128i, b: __m128) -> __m128 {
24402 unsafe { transmute(vpermi2ps128(a.as_f32x4(), idx.as_i32x4(), b.as_f32x4())) }
24403}
24404
24405#[inline]
24409#[target_feature(enable = "avx512f,avx512vl")]
24410#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24411#[cfg_attr(test, assert_instr(vpermt2ps))]
24412pub fn _mm_mask_permutex2var_ps(a: __m128, k: __mmask8, idx: __m128i, b: __m128) -> __m128 {
24413 unsafe {
24414 let permute = _mm_permutex2var_ps(a, idx, b).as_f32x4();
24415 transmute(simd_select_bitmask(k, permute, a.as_f32x4()))
24416 }
24417}
24418
24419#[inline]
24423#[target_feature(enable = "avx512f,avx512vl")]
24424#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24425#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_maskz_permutex2var_ps(k: __mmask8, a: __m128, idx: __m128i, b: __m128) -> __m128 {
24427 unsafe {
24428 let permute = _mm_permutex2var_ps(a, idx, b).as_f32x4();
24429 transmute(simd_select_bitmask(k, permute, f32x4::ZERO))
24430 }
24431}
24432
24433#[inline]
24437#[target_feature(enable = "avx512f,avx512vl")]
24438#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24439#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_mask2_permutex2var_ps(a: __m128, idx: __m128i, k: __mmask8, b: __m128) -> __m128 {
24441 unsafe {
24442 let permute = _mm_permutex2var_ps(a, idx, b).as_f32x4();
24443 let idx = _mm_castsi128_ps(idx).as_f32x4();
24444 transmute(simd_select_bitmask(k, permute, idx))
24445 }
24446}
24447
24448#[inline]
24452#[target_feature(enable = "avx512f")]
24453#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24454#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_permutex2var_pd(a: __m512d, idx: __m512i, b: __m512d) -> __m512d {
24456 unsafe { transmute(vpermi2pd(a.as_f64x8(), idx.as_i64x8(), b.as_f64x8())) }
24457}
24458
24459#[inline]
24463#[target_feature(enable = "avx512f")]
24464#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24465#[cfg_attr(test, assert_instr(vpermt2pd))]
24466pub fn _mm512_mask_permutex2var_pd(a: __m512d, k: __mmask8, idx: __m512i, b: __m512d) -> __m512d {
24467 unsafe {
24468 let permute = _mm512_permutex2var_pd(a, idx, b).as_f64x8();
24469 transmute(simd_select_bitmask(k, permute, a.as_f64x8()))
24470 }
24471}
24472
24473#[inline]
24477#[target_feature(enable = "avx512f")]
24478#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24479#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_maskz_permutex2var_pd(k: __mmask8, a: __m512d, idx: __m512i, b: __m512d) -> __m512d {
24481 unsafe {
24482 let permute = _mm512_permutex2var_pd(a, idx, b).as_f64x8();
24483 transmute(simd_select_bitmask(k, permute, f64x8::ZERO))
24484 }
24485}
24486
24487#[inline]
24491#[target_feature(enable = "avx512f")]
24492#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24493#[cfg_attr(test, assert_instr(vperm))] pub fn _mm512_mask2_permutex2var_pd(a: __m512d, idx: __m512i, k: __mmask8, b: __m512d) -> __m512d {
24495 unsafe {
24496 let permute = _mm512_permutex2var_pd(a, idx, b).as_f64x8();
24497 let idx = _mm512_castsi512_pd(idx).as_f64x8();
24498 transmute(simd_select_bitmask(k, permute, idx))
24499 }
24500}
24501
24502#[inline]
24506#[target_feature(enable = "avx512f,avx512vl")]
24507#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24508#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_permutex2var_pd(a: __m256d, idx: __m256i, b: __m256d) -> __m256d {
24510 unsafe { transmute(vpermi2pd256(a.as_f64x4(), idx.as_i64x4(), b.as_f64x4())) }
24511}
24512
24513#[inline]
24517#[target_feature(enable = "avx512f,avx512vl")]
24518#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24519#[cfg_attr(test, assert_instr(vpermt2pd))]
24520pub fn _mm256_mask_permutex2var_pd(a: __m256d, k: __mmask8, idx: __m256i, b: __m256d) -> __m256d {
24521 unsafe {
24522 let permute = _mm256_permutex2var_pd(a, idx, b).as_f64x4();
24523 transmute(simd_select_bitmask(k, permute, a.as_f64x4()))
24524 }
24525}
24526
24527#[inline]
24531#[target_feature(enable = "avx512f,avx512vl")]
24532#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24533#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_maskz_permutex2var_pd(k: __mmask8, a: __m256d, idx: __m256i, b: __m256d) -> __m256d {
24535 unsafe {
24536 let permute = _mm256_permutex2var_pd(a, idx, b).as_f64x4();
24537 transmute(simd_select_bitmask(k, permute, f64x4::ZERO))
24538 }
24539}
24540
24541#[inline]
24545#[target_feature(enable = "avx512f,avx512vl")]
24546#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24547#[cfg_attr(test, assert_instr(vperm))] pub fn _mm256_mask2_permutex2var_pd(a: __m256d, idx: __m256i, k: __mmask8, b: __m256d) -> __m256d {
24549 unsafe {
24550 let permute = _mm256_permutex2var_pd(a, idx, b).as_f64x4();
24551 let idx = _mm256_castsi256_pd(idx).as_f64x4();
24552 transmute(simd_select_bitmask(k, permute, idx))
24553 }
24554}
24555
24556#[inline]
24560#[target_feature(enable = "avx512f,avx512vl")]
24561#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24562#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_permutex2var_pd(a: __m128d, idx: __m128i, b: __m128d) -> __m128d {
24564 unsafe { transmute(vpermi2pd128(a.as_f64x2(), idx.as_i64x2(), b.as_f64x2())) }
24565}
24566
24567#[inline]
24571#[target_feature(enable = "avx512f,avx512vl")]
24572#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24573#[cfg_attr(test, assert_instr(vpermt2pd))]
24574pub fn _mm_mask_permutex2var_pd(a: __m128d, k: __mmask8, idx: __m128i, b: __m128d) -> __m128d {
24575 unsafe {
24576 let permute = _mm_permutex2var_pd(a, idx, b).as_f64x2();
24577 transmute(simd_select_bitmask(k, permute, a.as_f64x2()))
24578 }
24579}
24580
24581#[inline]
24585#[target_feature(enable = "avx512f,avx512vl")]
24586#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24587#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_maskz_permutex2var_pd(k: __mmask8, a: __m128d, idx: __m128i, b: __m128d) -> __m128d {
24589 unsafe {
24590 let permute = _mm_permutex2var_pd(a, idx, b).as_f64x2();
24591 transmute(simd_select_bitmask(k, permute, f64x2::ZERO))
24592 }
24593}
24594
24595#[inline]
24599#[target_feature(enable = "avx512f,avx512vl")]
24600#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24601#[cfg_attr(test, assert_instr(vperm))] pub fn _mm_mask2_permutex2var_pd(a: __m128d, idx: __m128i, k: __mmask8, b: __m128d) -> __m128d {
24603 unsafe {
24604 let permute = _mm_permutex2var_pd(a, idx, b).as_f64x2();
24605 let idx = _mm_castsi128_pd(idx).as_f64x2();
24606 transmute(simd_select_bitmask(k, permute, idx))
24607 }
24608}
24609
24610#[inline]
24614#[target_feature(enable = "avx512f")]
24615#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24616#[cfg_attr(test, assert_instr(vshufps, MASK = 9))] #[rustc_legacy_const_generics(1)]
24618#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24619pub const fn _mm512_shuffle_epi32<const MASK: _MM_PERM_ENUM>(a: __m512i) -> __m512i {
24620 unsafe {
24621 static_assert_uimm_bits!(MASK, 8);
24622 let r: i32x16 = simd_shuffle!(
24623 a.as_i32x16(),
24624 a.as_i32x16(),
24625 [
24626 MASK as u32 & 0b11,
24627 (MASK as u32 >> 2) & 0b11,
24628 (MASK as u32 >> 4) & 0b11,
24629 (MASK as u32 >> 6) & 0b11,
24630 (MASK as u32 & 0b11) + 4,
24631 ((MASK as u32 >> 2) & 0b11) + 4,
24632 ((MASK as u32 >> 4) & 0b11) + 4,
24633 ((MASK as u32 >> 6) & 0b11) + 4,
24634 (MASK as u32 & 0b11) + 8,
24635 ((MASK as u32 >> 2) & 0b11) + 8,
24636 ((MASK as u32 >> 4) & 0b11) + 8,
24637 ((MASK as u32 >> 6) & 0b11) + 8,
24638 (MASK as u32 & 0b11) + 12,
24639 ((MASK as u32 >> 2) & 0b11) + 12,
24640 ((MASK as u32 >> 4) & 0b11) + 12,
24641 ((MASK as u32 >> 6) & 0b11) + 12,
24642 ],
24643 );
24644 transmute(r)
24645 }
24646}
24647
24648#[inline]
24652#[target_feature(enable = "avx512f")]
24653#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24654#[cfg_attr(test, assert_instr(vpshufd, MASK = 9))]
24655#[rustc_legacy_const_generics(3)]
24656#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24657pub const fn _mm512_mask_shuffle_epi32<const MASK: _MM_PERM_ENUM>(
24658 src: __m512i,
24659 k: __mmask16,
24660 a: __m512i,
24661) -> __m512i {
24662 unsafe {
24663 static_assert_uimm_bits!(MASK, 8);
24664 let r = _mm512_shuffle_epi32::<MASK>(a);
24665 transmute(simd_select_bitmask(k, r.as_i32x16(), src.as_i32x16()))
24666 }
24667}
24668
24669#[inline]
24673#[target_feature(enable = "avx512f")]
24674#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24675#[cfg_attr(test, assert_instr(vpshufd, MASK = 9))]
24676#[rustc_legacy_const_generics(2)]
24677#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24678pub const fn _mm512_maskz_shuffle_epi32<const MASK: _MM_PERM_ENUM>(
24679 k: __mmask16,
24680 a: __m512i,
24681) -> __m512i {
24682 unsafe {
24683 static_assert_uimm_bits!(MASK, 8);
24684 let r = _mm512_shuffle_epi32::<MASK>(a);
24685 transmute(simd_select_bitmask(k, r.as_i32x16(), i32x16::ZERO))
24686 }
24687}
24688
24689#[inline]
24693#[target_feature(enable = "avx512f,avx512vl")]
24694#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24695#[cfg_attr(test, assert_instr(vpshufd, MASK = 9))]
24696#[rustc_legacy_const_generics(3)]
24697#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24698pub const fn _mm256_mask_shuffle_epi32<const MASK: _MM_PERM_ENUM>(
24699 src: __m256i,
24700 k: __mmask8,
24701 a: __m256i,
24702) -> __m256i {
24703 unsafe {
24704 static_assert_uimm_bits!(MASK, 8);
24705 let r = _mm256_shuffle_epi32::<MASK>(a);
24706 transmute(simd_select_bitmask(k, r.as_i32x8(), src.as_i32x8()))
24707 }
24708}
24709
24710#[inline]
24714#[target_feature(enable = "avx512f,avx512vl")]
24715#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24716#[cfg_attr(test, assert_instr(vpshufd, MASK = 9))]
24717#[rustc_legacy_const_generics(2)]
24718#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24719pub const fn _mm256_maskz_shuffle_epi32<const MASK: _MM_PERM_ENUM>(
24720 k: __mmask8,
24721 a: __m256i,
24722) -> __m256i {
24723 unsafe {
24724 static_assert_uimm_bits!(MASK, 8);
24725 let r = _mm256_shuffle_epi32::<MASK>(a);
24726 transmute(simd_select_bitmask(k, r.as_i32x8(), i32x8::ZERO))
24727 }
24728}
24729
24730#[inline]
24734#[target_feature(enable = "avx512f,avx512vl")]
24735#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24736#[cfg_attr(test, assert_instr(vpshufd, MASK = 9))]
24737#[rustc_legacy_const_generics(3)]
24738#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24739pub const fn _mm_mask_shuffle_epi32<const MASK: _MM_PERM_ENUM>(
24740 src: __m128i,
24741 k: __mmask8,
24742 a: __m128i,
24743) -> __m128i {
24744 unsafe {
24745 static_assert_uimm_bits!(MASK, 8);
24746 let r = _mm_shuffle_epi32::<MASK>(a);
24747 transmute(simd_select_bitmask(k, r.as_i32x4(), src.as_i32x4()))
24748 }
24749}
24750
24751#[inline]
24755#[target_feature(enable = "avx512f,avx512vl")]
24756#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24757#[cfg_attr(test, assert_instr(vpshufd, MASK = 9))]
24758#[rustc_legacy_const_generics(2)]
24759#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24760pub const fn _mm_maskz_shuffle_epi32<const MASK: _MM_PERM_ENUM>(
24761 k: __mmask8,
24762 a: __m128i,
24763) -> __m128i {
24764 unsafe {
24765 static_assert_uimm_bits!(MASK, 8);
24766 let r = _mm_shuffle_epi32::<MASK>(a);
24767 transmute(simd_select_bitmask(k, r.as_i32x4(), i32x4::ZERO))
24768 }
24769}
24770
24771#[inline]
24775#[target_feature(enable = "avx512f")]
24776#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24777#[cfg_attr(test, assert_instr(vshufps, MASK = 3))]
24778#[rustc_legacy_const_generics(2)]
24779#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24780pub const fn _mm512_shuffle_ps<const MASK: i32>(a: __m512, b: __m512) -> __m512 {
24781 unsafe {
24782 static_assert_uimm_bits!(MASK, 8);
24783 simd_shuffle!(
24784 a,
24785 b,
24786 [
24787 MASK as u32 & 0b11,
24788 (MASK as u32 >> 2) & 0b11,
24789 ((MASK as u32 >> 4) & 0b11) + 16,
24790 ((MASK as u32 >> 6) & 0b11) + 16,
24791 (MASK as u32 & 0b11) + 4,
24792 ((MASK as u32 >> 2) & 0b11) + 4,
24793 ((MASK as u32 >> 4) & 0b11) + 20,
24794 ((MASK as u32 >> 6) & 0b11) + 20,
24795 (MASK as u32 & 0b11) + 8,
24796 ((MASK as u32 >> 2) & 0b11) + 8,
24797 ((MASK as u32 >> 4) & 0b11) + 24,
24798 ((MASK as u32 >> 6) & 0b11) + 24,
24799 (MASK as u32 & 0b11) + 12,
24800 ((MASK as u32 >> 2) & 0b11) + 12,
24801 ((MASK as u32 >> 4) & 0b11) + 28,
24802 ((MASK as u32 >> 6) & 0b11) + 28,
24803 ],
24804 )
24805 }
24806}
24807
24808#[inline]
24812#[target_feature(enable = "avx512f")]
24813#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24814#[cfg_attr(test, assert_instr(vshufps, MASK = 3))]
24815#[rustc_legacy_const_generics(4)]
24816#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24817pub const fn _mm512_mask_shuffle_ps<const MASK: i32>(
24818 src: __m512,
24819 k: __mmask16,
24820 a: __m512,
24821 b: __m512,
24822) -> __m512 {
24823 unsafe {
24824 static_assert_uimm_bits!(MASK, 8);
24825 let r = _mm512_shuffle_ps::<MASK>(a, b);
24826 transmute(simd_select_bitmask(k, r.as_f32x16(), src.as_f32x16()))
24827 }
24828}
24829
24830#[inline]
24834#[target_feature(enable = "avx512f")]
24835#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24836#[cfg_attr(test, assert_instr(vshufps, MASK = 3))]
24837#[rustc_legacy_const_generics(3)]
24838#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24839pub const fn _mm512_maskz_shuffle_ps<const MASK: i32>(
24840 k: __mmask16,
24841 a: __m512,
24842 b: __m512,
24843) -> __m512 {
24844 unsafe {
24845 static_assert_uimm_bits!(MASK, 8);
24846 let r = _mm512_shuffle_ps::<MASK>(a, b);
24847 transmute(simd_select_bitmask(k, r.as_f32x16(), f32x16::ZERO))
24848 }
24849}
24850
24851#[inline]
24855#[target_feature(enable = "avx512f,avx512vl")]
24856#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24857#[cfg_attr(test, assert_instr(vshufps, MASK = 3))]
24858#[rustc_legacy_const_generics(4)]
24859#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24860pub const fn _mm256_mask_shuffle_ps<const MASK: i32>(
24861 src: __m256,
24862 k: __mmask8,
24863 a: __m256,
24864 b: __m256,
24865) -> __m256 {
24866 unsafe {
24867 static_assert_uimm_bits!(MASK, 8);
24868 let r = _mm256_shuffle_ps::<MASK>(a, b);
24869 transmute(simd_select_bitmask(k, r.as_f32x8(), src.as_f32x8()))
24870 }
24871}
24872
24873#[inline]
24877#[target_feature(enable = "avx512f,avx512vl")]
24878#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24879#[cfg_attr(test, assert_instr(vshufps, MASK = 3))]
24880#[rustc_legacy_const_generics(3)]
24881#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24882pub const fn _mm256_maskz_shuffle_ps<const MASK: i32>(k: __mmask8, a: __m256, b: __m256) -> __m256 {
24883 unsafe {
24884 static_assert_uimm_bits!(MASK, 8);
24885 let r = _mm256_shuffle_ps::<MASK>(a, b);
24886 transmute(simd_select_bitmask(k, r.as_f32x8(), f32x8::ZERO))
24887 }
24888}
24889
24890#[inline]
24894#[target_feature(enable = "avx512f,avx512vl")]
24895#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24896#[cfg_attr(test, assert_instr(vshufps, MASK = 3))]
24897#[rustc_legacy_const_generics(4)]
24898#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24899pub const fn _mm_mask_shuffle_ps<const MASK: i32>(
24900 src: __m128,
24901 k: __mmask8,
24902 a: __m128,
24903 b: __m128,
24904) -> __m128 {
24905 unsafe {
24906 static_assert_uimm_bits!(MASK, 8);
24907 let r = _mm_shuffle_ps::<MASK>(a, b);
24908 transmute(simd_select_bitmask(k, r.as_f32x4(), src.as_f32x4()))
24909 }
24910}
24911
24912#[inline]
24916#[target_feature(enable = "avx512f,avx512vl")]
24917#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24918#[cfg_attr(test, assert_instr(vshufps, MASK = 3))]
24919#[rustc_legacy_const_generics(3)]
24920#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24921pub const fn _mm_maskz_shuffle_ps<const MASK: i32>(k: __mmask8, a: __m128, b: __m128) -> __m128 {
24922 unsafe {
24923 static_assert_uimm_bits!(MASK, 8);
24924 let r = _mm_shuffle_ps::<MASK>(a, b);
24925 transmute(simd_select_bitmask(k, r.as_f32x4(), f32x4::ZERO))
24926 }
24927}
24928
24929#[inline]
24933#[target_feature(enable = "avx512f")]
24934#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24935#[cfg_attr(test, assert_instr(vshufpd, MASK = 3))]
24936#[rustc_legacy_const_generics(2)]
24937#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24938pub const fn _mm512_shuffle_pd<const MASK: i32>(a: __m512d, b: __m512d) -> __m512d {
24939 unsafe {
24940 static_assert_uimm_bits!(MASK, 8);
24941 simd_shuffle!(
24942 a,
24943 b,
24944 [
24945 MASK as u32 & 0b1,
24946 ((MASK as u32 >> 1) & 0b1) + 8,
24947 ((MASK as u32 >> 2) & 0b1) + 2,
24948 ((MASK as u32 >> 3) & 0b1) + 10,
24949 ((MASK as u32 >> 4) & 0b1) + 4,
24950 ((MASK as u32 >> 5) & 0b1) + 12,
24951 ((MASK as u32 >> 6) & 0b1) + 6,
24952 ((MASK as u32 >> 7) & 0b1) + 14,
24953 ],
24954 )
24955 }
24956}
24957
24958#[inline]
24962#[target_feature(enable = "avx512f")]
24963#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24964#[cfg_attr(test, assert_instr(vshufpd, MASK = 3))]
24965#[rustc_legacy_const_generics(4)]
24966#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24967pub const fn _mm512_mask_shuffle_pd<const MASK: i32>(
24968 src: __m512d,
24969 k: __mmask8,
24970 a: __m512d,
24971 b: __m512d,
24972) -> __m512d {
24973 unsafe {
24974 static_assert_uimm_bits!(MASK, 8);
24975 let r = _mm512_shuffle_pd::<MASK>(a, b);
24976 transmute(simd_select_bitmask(k, r.as_f64x8(), src.as_f64x8()))
24977 }
24978}
24979
24980#[inline]
24984#[target_feature(enable = "avx512f")]
24985#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
24986#[cfg_attr(test, assert_instr(vshufpd, MASK = 3))]
24987#[rustc_legacy_const_generics(3)]
24988#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
24989pub const fn _mm512_maskz_shuffle_pd<const MASK: i32>(
24990 k: __mmask8,
24991 a: __m512d,
24992 b: __m512d,
24993) -> __m512d {
24994 unsafe {
24995 static_assert_uimm_bits!(MASK, 8);
24996 let r = _mm512_shuffle_pd::<MASK>(a, b);
24997 transmute(simd_select_bitmask(k, r.as_f64x8(), f64x8::ZERO))
24998 }
24999}
25000
25001#[inline]
25005#[target_feature(enable = "avx512f,avx512vl")]
25006#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25007#[cfg_attr(test, assert_instr(vshufpd, MASK = 3))]
25008#[rustc_legacy_const_generics(4)]
25009#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25010pub const fn _mm256_mask_shuffle_pd<const MASK: i32>(
25011 src: __m256d,
25012 k: __mmask8,
25013 a: __m256d,
25014 b: __m256d,
25015) -> __m256d {
25016 unsafe {
25017 static_assert_uimm_bits!(MASK, 8);
25018 let r = _mm256_shuffle_pd::<MASK>(a, b);
25019 transmute(simd_select_bitmask(k, r.as_f64x4(), src.as_f64x4()))
25020 }
25021}
25022
25023#[inline]
25027#[target_feature(enable = "avx512f,avx512vl")]
25028#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25029#[cfg_attr(test, assert_instr(vshufpd, MASK = 3))]
25030#[rustc_legacy_const_generics(3)]
25031#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25032pub const fn _mm256_maskz_shuffle_pd<const MASK: i32>(
25033 k: __mmask8,
25034 a: __m256d,
25035 b: __m256d,
25036) -> __m256d {
25037 unsafe {
25038 static_assert_uimm_bits!(MASK, 8);
25039 let r = _mm256_shuffle_pd::<MASK>(a, b);
25040 transmute(simd_select_bitmask(k, r.as_f64x4(), f64x4::ZERO))
25041 }
25042}
25043
25044#[inline]
25048#[target_feature(enable = "avx512f,avx512vl")]
25049#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25050#[cfg_attr(test, assert_instr(vshufpd, MASK = 1))]
25051#[rustc_legacy_const_generics(4)]
25052#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25053pub const fn _mm_mask_shuffle_pd<const MASK: i32>(
25054 src: __m128d,
25055 k: __mmask8,
25056 a: __m128d,
25057 b: __m128d,
25058) -> __m128d {
25059 unsafe {
25060 static_assert_uimm_bits!(MASK, 8);
25061 let r = _mm_shuffle_pd::<MASK>(a, b);
25062 transmute(simd_select_bitmask(k, r.as_f64x2(), src.as_f64x2()))
25063 }
25064}
25065
25066#[inline]
25070#[target_feature(enable = "avx512f,avx512vl")]
25071#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25072#[cfg_attr(test, assert_instr(vshufpd, MASK = 1))]
25073#[rustc_legacy_const_generics(3)]
25074#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25075pub const fn _mm_maskz_shuffle_pd<const MASK: i32>(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
25076 unsafe {
25077 static_assert_uimm_bits!(MASK, 8);
25078 let r = _mm_shuffle_pd::<MASK>(a, b);
25079 transmute(simd_select_bitmask(k, r.as_f64x2(), f64x2::ZERO))
25080 }
25081}
25082
25083#[inline]
25087#[target_feature(enable = "avx512f")]
25088#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25089#[cfg_attr(test, assert_instr(vshufi64x2, MASK = 0b10_01_01_01))] #[rustc_legacy_const_generics(2)]
25091#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25092pub const fn _mm512_shuffle_i32x4<const MASK: i32>(a: __m512i, b: __m512i) -> __m512i {
25093 unsafe {
25094 static_assert_uimm_bits!(MASK, 8);
25095 let a = a.as_i32x16();
25096 let b = b.as_i32x16();
25097 let r: i32x16 = simd_shuffle!(
25098 a,
25099 b,
25100 [
25101 (MASK as u32 & 0b11) * 4 + 0,
25102 (MASK as u32 & 0b11) * 4 + 1,
25103 (MASK as u32 & 0b11) * 4 + 2,
25104 (MASK as u32 & 0b11) * 4 + 3,
25105 ((MASK as u32 >> 2) & 0b11) * 4 + 0,
25106 ((MASK as u32 >> 2) & 0b11) * 4 + 1,
25107 ((MASK as u32 >> 2) & 0b11) * 4 + 2,
25108 ((MASK as u32 >> 2) & 0b11) * 4 + 3,
25109 ((MASK as u32 >> 4) & 0b11) * 4 + 0 + 16,
25110 ((MASK as u32 >> 4) & 0b11) * 4 + 1 + 16,
25111 ((MASK as u32 >> 4) & 0b11) * 4 + 2 + 16,
25112 ((MASK as u32 >> 4) & 0b11) * 4 + 3 + 16,
25113 ((MASK as u32 >> 6) & 0b11) * 4 + 0 + 16,
25114 ((MASK as u32 >> 6) & 0b11) * 4 + 1 + 16,
25115 ((MASK as u32 >> 6) & 0b11) * 4 + 2 + 16,
25116 ((MASK as u32 >> 6) & 0b11) * 4 + 3 + 16,
25117 ],
25118 );
25119 transmute(r)
25120 }
25121}
25122
25123#[inline]
25127#[target_feature(enable = "avx512f")]
25128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25129#[cfg_attr(test, assert_instr(vshufi32x4, MASK = 0b10_11_01_01))]
25130#[rustc_legacy_const_generics(4)]
25131#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25132pub const fn _mm512_mask_shuffle_i32x4<const MASK: i32>(
25133 src: __m512i,
25134 k: __mmask16,
25135 a: __m512i,
25136 b: __m512i,
25137) -> __m512i {
25138 unsafe {
25139 static_assert_uimm_bits!(MASK, 8);
25140 let r = _mm512_shuffle_i32x4::<MASK>(a, b);
25141 transmute(simd_select_bitmask(k, r.as_i32x16(), src.as_i32x16()))
25142 }
25143}
25144
25145#[inline]
25149#[target_feature(enable = "avx512f")]
25150#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25151#[cfg_attr(test, assert_instr(vshufi32x4, MASK = 0b10_11_01_01))]
25152#[rustc_legacy_const_generics(3)]
25153#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25154pub const fn _mm512_maskz_shuffle_i32x4<const MASK: i32>(
25155 k: __mmask16,
25156 a: __m512i,
25157 b: __m512i,
25158) -> __m512i {
25159 unsafe {
25160 static_assert_uimm_bits!(MASK, 8);
25161 let r = _mm512_shuffle_i32x4::<MASK>(a, b);
25162 transmute(simd_select_bitmask(k, r.as_i32x16(), i32x16::ZERO))
25163 }
25164}
25165
25166#[inline]
25170#[target_feature(enable = "avx512f,avx512vl")]
25171#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25172#[cfg_attr(test, assert_instr(vperm, MASK = 0b11))] #[rustc_legacy_const_generics(2)]
25174#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25175pub const fn _mm256_shuffle_i32x4<const MASK: i32>(a: __m256i, b: __m256i) -> __m256i {
25176 unsafe {
25177 static_assert_uimm_bits!(MASK, 8);
25178 let a = a.as_i32x8();
25179 let b = b.as_i32x8();
25180 let r: i32x8 = simd_shuffle!(
25181 a,
25182 b,
25183 [
25184 (MASK as u32 & 0b1) * 4 + 0,
25185 (MASK as u32 & 0b1) * 4 + 1,
25186 (MASK as u32 & 0b1) * 4 + 2,
25187 (MASK as u32 & 0b1) * 4 + 3,
25188 ((MASK as u32 >> 1) & 0b1) * 4 + 0 + 8,
25189 ((MASK as u32 >> 1) & 0b1) * 4 + 1 + 8,
25190 ((MASK as u32 >> 1) & 0b1) * 4 + 2 + 8,
25191 ((MASK as u32 >> 1) & 0b1) * 4 + 3 + 8,
25192 ],
25193 );
25194 transmute(r)
25195 }
25196}
25197
25198#[inline]
25202#[target_feature(enable = "avx512f,avx512vl")]
25203#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25204#[cfg_attr(test, assert_instr(vshufi32x4, MASK = 0b11))]
25205#[rustc_legacy_const_generics(4)]
25206#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25207pub const fn _mm256_mask_shuffle_i32x4<const MASK: i32>(
25208 src: __m256i,
25209 k: __mmask8,
25210 a: __m256i,
25211 b: __m256i,
25212) -> __m256i {
25213 unsafe {
25214 static_assert_uimm_bits!(MASK, 8);
25215 let r = _mm256_shuffle_i32x4::<MASK>(a, b);
25216 transmute(simd_select_bitmask(k, r.as_i32x8(), src.as_i32x8()))
25217 }
25218}
25219
25220#[inline]
25224#[target_feature(enable = "avx512f,avx512vl")]
25225#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25226#[cfg_attr(test, assert_instr(vshufi32x4, MASK = 0b11))]
25227#[rustc_legacy_const_generics(3)]
25228#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25229pub const fn _mm256_maskz_shuffle_i32x4<const MASK: i32>(
25230 k: __mmask8,
25231 a: __m256i,
25232 b: __m256i,
25233) -> __m256i {
25234 unsafe {
25235 static_assert_uimm_bits!(MASK, 8);
25236 let r = _mm256_shuffle_i32x4::<MASK>(a, b);
25237 transmute(simd_select_bitmask(k, r.as_i32x8(), i32x8::ZERO))
25238 }
25239}
25240
25241#[inline]
25245#[target_feature(enable = "avx512f")]
25246#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25247#[cfg_attr(test, assert_instr(vshufi64x2, MASK = 0b10_11_11_11))]
25248#[rustc_legacy_const_generics(2)]
25249#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25250pub const fn _mm512_shuffle_i64x2<const MASK: i32>(a: __m512i, b: __m512i) -> __m512i {
25251 unsafe {
25252 static_assert_uimm_bits!(MASK, 8);
25253 let a = a.as_i64x8();
25254 let b = b.as_i64x8();
25255 let r: i64x8 = simd_shuffle!(
25256 a,
25257 b,
25258 [
25259 (MASK as u32 & 0b11) * 2 + 0,
25260 (MASK as u32 & 0b11) * 2 + 1,
25261 ((MASK as u32 >> 2) & 0b11) * 2 + 0,
25262 ((MASK as u32 >> 2) & 0b11) * 2 + 1,
25263 ((MASK as u32 >> 4) & 0b11) * 2 + 0 + 8,
25264 ((MASK as u32 >> 4) & 0b11) * 2 + 1 + 8,
25265 ((MASK as u32 >> 6) & 0b11) * 2 + 0 + 8,
25266 ((MASK as u32 >> 6) & 0b11) * 2 + 1 + 8,
25267 ],
25268 );
25269 transmute(r)
25270 }
25271}
25272
25273#[inline]
25277#[target_feature(enable = "avx512f")]
25278#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25279#[cfg_attr(test, assert_instr(vshufi64x2, MASK = 0b10_11_11_11))]
25280#[rustc_legacy_const_generics(4)]
25281#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25282pub const fn _mm512_mask_shuffle_i64x2<const MASK: i32>(
25283 src: __m512i,
25284 k: __mmask8,
25285 a: __m512i,
25286 b: __m512i,
25287) -> __m512i {
25288 unsafe {
25289 static_assert_uimm_bits!(MASK, 8);
25290 let r = _mm512_shuffle_i64x2::<MASK>(a, b);
25291 transmute(simd_select_bitmask(k, r.as_i64x8(), src.as_i64x8()))
25292 }
25293}
25294
25295#[inline]
25299#[target_feature(enable = "avx512f")]
25300#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25301#[cfg_attr(test, assert_instr(vshufi64x2, MASK = 0b10_11_11_11))]
25302#[rustc_legacy_const_generics(3)]
25303#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25304pub const fn _mm512_maskz_shuffle_i64x2<const MASK: i32>(
25305 k: __mmask8,
25306 a: __m512i,
25307 b: __m512i,
25308) -> __m512i {
25309 unsafe {
25310 static_assert_uimm_bits!(MASK, 8);
25311 let r = _mm512_shuffle_i64x2::<MASK>(a, b);
25312 transmute(simd_select_bitmask(k, r.as_i64x8(), i64x8::ZERO))
25313 }
25314}
25315
25316#[inline]
25320#[target_feature(enable = "avx512f,avx512vl")]
25321#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25322#[cfg_attr(test, assert_instr(vperm, MASK = 0b01))] #[rustc_legacy_const_generics(2)]
25324#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25325pub const fn _mm256_shuffle_i64x2<const MASK: i32>(a: __m256i, b: __m256i) -> __m256i {
25326 unsafe {
25327 static_assert_uimm_bits!(MASK, 8);
25328 let a = a.as_i64x4();
25329 let b = b.as_i64x4();
25330 let r: i64x4 = simd_shuffle!(
25331 a,
25332 b,
25333 [
25334 (MASK as u32 & 0b1) * 2 + 0,
25335 (MASK as u32 & 0b1) * 2 + 1,
25336 ((MASK as u32 >> 1) & 0b1) * 2 + 0 + 4,
25337 ((MASK as u32 >> 1) & 0b1) * 2 + 1 + 4,
25338 ],
25339 );
25340 transmute(r)
25341 }
25342}
25343
25344#[inline]
25348#[target_feature(enable = "avx512f,avx512vl")]
25349#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25350#[cfg_attr(test, assert_instr(vshufi64x2, MASK = 0b11))]
25351#[rustc_legacy_const_generics(4)]
25352#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25353pub const fn _mm256_mask_shuffle_i64x2<const MASK: i32>(
25354 src: __m256i,
25355 k: __mmask8,
25356 a: __m256i,
25357 b: __m256i,
25358) -> __m256i {
25359 unsafe {
25360 static_assert_uimm_bits!(MASK, 8);
25361 let r = _mm256_shuffle_i64x2::<MASK>(a, b);
25362 transmute(simd_select_bitmask(k, r.as_i64x4(), src.as_i64x4()))
25363 }
25364}
25365
25366#[inline]
25370#[target_feature(enable = "avx512f,avx512vl")]
25371#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25372#[cfg_attr(test, assert_instr(vshufi64x2, MASK = 0b11))]
25373#[rustc_legacy_const_generics(3)]
25374#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25375pub const fn _mm256_maskz_shuffle_i64x2<const MASK: i32>(
25376 k: __mmask8,
25377 a: __m256i,
25378 b: __m256i,
25379) -> __m256i {
25380 unsafe {
25381 static_assert_uimm_bits!(MASK, 8);
25382 let r = _mm256_shuffle_i64x2::<MASK>(a, b);
25383 transmute(simd_select_bitmask(k, r.as_i64x4(), i64x4::ZERO))
25384 }
25385}
25386
25387#[inline]
25391#[target_feature(enable = "avx512f")]
25392#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25393#[cfg_attr(test, assert_instr(vshuff64x2, MASK = 0b1011))] #[rustc_legacy_const_generics(2)]
25395#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25396pub const fn _mm512_shuffle_f32x4<const MASK: i32>(a: __m512, b: __m512) -> __m512 {
25397 unsafe {
25398 static_assert_uimm_bits!(MASK, 8);
25399 let a = a.as_f32x16();
25400 let b = b.as_f32x16();
25401 let r: f32x16 = simd_shuffle!(
25402 a,
25403 b,
25404 [
25405 (MASK as u32 & 0b11) * 4 + 0,
25406 (MASK as u32 & 0b11) * 4 + 1,
25407 (MASK as u32 & 0b11) * 4 + 2,
25408 (MASK as u32 & 0b11) * 4 + 3,
25409 ((MASK as u32 >> 2) & 0b11) * 4 + 0,
25410 ((MASK as u32 >> 2) & 0b11) * 4 + 1,
25411 ((MASK as u32 >> 2) & 0b11) * 4 + 2,
25412 ((MASK as u32 >> 2) & 0b11) * 4 + 3,
25413 ((MASK as u32 >> 4) & 0b11) * 4 + 0 + 16,
25414 ((MASK as u32 >> 4) & 0b11) * 4 + 1 + 16,
25415 ((MASK as u32 >> 4) & 0b11) * 4 + 2 + 16,
25416 ((MASK as u32 >> 4) & 0b11) * 4 + 3 + 16,
25417 ((MASK as u32 >> 6) & 0b11) * 4 + 0 + 16,
25418 ((MASK as u32 >> 6) & 0b11) * 4 + 1 + 16,
25419 ((MASK as u32 >> 6) & 0b11) * 4 + 2 + 16,
25420 ((MASK as u32 >> 6) & 0b11) * 4 + 3 + 16,
25421 ],
25422 );
25423 transmute(r)
25424 }
25425}
25426
25427#[inline]
25431#[target_feature(enable = "avx512f")]
25432#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25433#[cfg_attr(test, assert_instr(vshuff32x4, MASK = 0b1011))]
25434#[rustc_legacy_const_generics(4)]
25435#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25436pub const fn _mm512_mask_shuffle_f32x4<const MASK: i32>(
25437 src: __m512,
25438 k: __mmask16,
25439 a: __m512,
25440 b: __m512,
25441) -> __m512 {
25442 unsafe {
25443 static_assert_uimm_bits!(MASK, 8);
25444 let r = _mm512_shuffle_f32x4::<MASK>(a, b);
25445 transmute(simd_select_bitmask(k, r.as_f32x16(), src.as_f32x16()))
25446 }
25447}
25448
25449#[inline]
25453#[target_feature(enable = "avx512f")]
25454#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25455#[cfg_attr(test, assert_instr(vshuff32x4, MASK = 0b1011))]
25456#[rustc_legacy_const_generics(3)]
25457#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25458pub const fn _mm512_maskz_shuffle_f32x4<const MASK: i32>(
25459 k: __mmask16,
25460 a: __m512,
25461 b: __m512,
25462) -> __m512 {
25463 unsafe {
25464 static_assert_uimm_bits!(MASK, 8);
25465 let r = _mm512_shuffle_f32x4::<MASK>(a, b);
25466 transmute(simd_select_bitmask(k, r.as_f32x16(), f32x16::ZERO))
25467 }
25468}
25469
25470#[inline]
25474#[target_feature(enable = "avx512f,avx512vl")]
25475#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25476#[cfg_attr(test, assert_instr(vperm, MASK = 0b01))] #[rustc_legacy_const_generics(2)]
25478#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25479pub const fn _mm256_shuffle_f32x4<const MASK: i32>(a: __m256, b: __m256) -> __m256 {
25480 unsafe {
25481 static_assert_uimm_bits!(MASK, 8);
25482 let a = a.as_f32x8();
25483 let b = b.as_f32x8();
25484 let r: f32x8 = simd_shuffle!(
25485 a,
25486 b,
25487 [
25488 (MASK as u32 & 0b1) * 4 + 0,
25489 (MASK as u32 & 0b1) * 4 + 1,
25490 (MASK as u32 & 0b1) * 4 + 2,
25491 (MASK as u32 & 0b1) * 4 + 3,
25492 ((MASK as u32 >> 1) & 0b1) * 4 + 0 + 8,
25493 ((MASK as u32 >> 1) & 0b1) * 4 + 1 + 8,
25494 ((MASK as u32 >> 1) & 0b1) * 4 + 2 + 8,
25495 ((MASK as u32 >> 1) & 0b1) * 4 + 3 + 8,
25496 ],
25497 );
25498 transmute(r)
25499 }
25500}
25501
25502#[inline]
25506#[target_feature(enable = "avx512f,avx512vl")]
25507#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25508#[cfg_attr(test, assert_instr(vshuff32x4, MASK = 0b11))]
25509#[rustc_legacy_const_generics(4)]
25510#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25511pub const fn _mm256_mask_shuffle_f32x4<const MASK: i32>(
25512 src: __m256,
25513 k: __mmask8,
25514 a: __m256,
25515 b: __m256,
25516) -> __m256 {
25517 unsafe {
25518 static_assert_uimm_bits!(MASK, 8);
25519 let r = _mm256_shuffle_f32x4::<MASK>(a, b);
25520 transmute(simd_select_bitmask(k, r.as_f32x8(), src.as_f32x8()))
25521 }
25522}
25523
25524#[inline]
25528#[target_feature(enable = "avx512f,avx512vl")]
25529#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25530#[cfg_attr(test, assert_instr(vshuff32x4, MASK = 0b11))]
25531#[rustc_legacy_const_generics(3)]
25532#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25533pub const fn _mm256_maskz_shuffle_f32x4<const MASK: i32>(
25534 k: __mmask8,
25535 a: __m256,
25536 b: __m256,
25537) -> __m256 {
25538 unsafe {
25539 static_assert_uimm_bits!(MASK, 8);
25540 let r = _mm256_shuffle_f32x4::<MASK>(a, b);
25541 transmute(simd_select_bitmask(k, r.as_f32x8(), f32x8::ZERO))
25542 }
25543}
25544
25545#[inline]
25549#[target_feature(enable = "avx512f")]
25550#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25551#[cfg_attr(test, assert_instr(vshuff64x2, MASK = 0b10_11_11_11))]
25552#[rustc_legacy_const_generics(2)]
25553#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25554pub const fn _mm512_shuffle_f64x2<const MASK: i32>(a: __m512d, b: __m512d) -> __m512d {
25555 unsafe {
25556 static_assert_uimm_bits!(MASK, 8);
25557 let a = a.as_f64x8();
25558 let b = b.as_f64x8();
25559 let r: f64x8 = simd_shuffle!(
25560 a,
25561 b,
25562 [
25563 (MASK as u32 & 0b11) * 2 + 0,
25564 (MASK as u32 & 0b11) * 2 + 1,
25565 ((MASK as u32 >> 2) & 0b11) * 2 + 0,
25566 ((MASK as u32 >> 2) & 0b11) * 2 + 1,
25567 ((MASK as u32 >> 4) & 0b11) * 2 + 0 + 8,
25568 ((MASK as u32 >> 4) & 0b11) * 2 + 1 + 8,
25569 ((MASK as u32 >> 6) & 0b11) * 2 + 0 + 8,
25570 ((MASK as u32 >> 6) & 0b11) * 2 + 1 + 8,
25571 ],
25572 );
25573 transmute(r)
25574 }
25575}
25576
25577#[inline]
25581#[target_feature(enable = "avx512f")]
25582#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25583#[cfg_attr(test, assert_instr(vshuff64x2, MASK = 0b10_11_11_11))]
25584#[rustc_legacy_const_generics(4)]
25585#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25586pub const fn _mm512_mask_shuffle_f64x2<const MASK: i32>(
25587 src: __m512d,
25588 k: __mmask8,
25589 a: __m512d,
25590 b: __m512d,
25591) -> __m512d {
25592 unsafe {
25593 static_assert_uimm_bits!(MASK, 8);
25594 let r = _mm512_shuffle_f64x2::<MASK>(a, b);
25595 transmute(simd_select_bitmask(k, r.as_f64x8(), src.as_f64x8()))
25596 }
25597}
25598
25599#[inline]
25603#[target_feature(enable = "avx512f")]
25604#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25605#[cfg_attr(test, assert_instr(vshuff64x2, MASK = 0b10_11_11_11))]
25606#[rustc_legacy_const_generics(3)]
25607#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25608pub const fn _mm512_maskz_shuffle_f64x2<const MASK: i32>(
25609 k: __mmask8,
25610 a: __m512d,
25611 b: __m512d,
25612) -> __m512d {
25613 unsafe {
25614 static_assert_uimm_bits!(MASK, 8);
25615 let r = _mm512_shuffle_f64x2::<MASK>(a, b);
25616 transmute(simd_select_bitmask(k, r.as_f64x8(), f64x8::ZERO))
25617 }
25618}
25619
25620#[inline]
25624#[target_feature(enable = "avx512f,avx512vl")]
25625#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25626#[cfg_attr(test, assert_instr(vperm, MASK = 0b01))] #[rustc_legacy_const_generics(2)]
25628#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25629pub const fn _mm256_shuffle_f64x2<const MASK: i32>(a: __m256d, b: __m256d) -> __m256d {
25630 unsafe {
25631 static_assert_uimm_bits!(MASK, 8);
25632 let a = a.as_f64x4();
25633 let b = b.as_f64x4();
25634 let r: f64x4 = simd_shuffle!(
25635 a,
25636 b,
25637 [
25638 (MASK as u32 & 0b1) * 2 + 0,
25639 (MASK as u32 & 0b1) * 2 + 1,
25640 ((MASK as u32 >> 1) & 0b1) * 2 + 0 + 4,
25641 ((MASK as u32 >> 1) & 0b1) * 2 + 1 + 4,
25642 ],
25643 );
25644 transmute(r)
25645 }
25646}
25647
25648#[inline]
25652#[target_feature(enable = "avx512f,avx512vl")]
25653#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25654#[cfg_attr(test, assert_instr(vshuff64x2, MASK = 0b11))]
25655#[rustc_legacy_const_generics(4)]
25656#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25657pub const fn _mm256_mask_shuffle_f64x2<const MASK: i32>(
25658 src: __m256d,
25659 k: __mmask8,
25660 a: __m256d,
25661 b: __m256d,
25662) -> __m256d {
25663 unsafe {
25664 static_assert_uimm_bits!(MASK, 8);
25665 let r = _mm256_shuffle_f64x2::<MASK>(a, b);
25666 transmute(simd_select_bitmask(k, r.as_f64x4(), src.as_f64x4()))
25667 }
25668}
25669
25670#[inline]
25674#[target_feature(enable = "avx512f,avx512vl")]
25675#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25676#[cfg_attr(test, assert_instr(vshuff64x2, MASK = 0b11))]
25677#[rustc_legacy_const_generics(3)]
25678#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25679pub const fn _mm256_maskz_shuffle_f64x2<const MASK: i32>(
25680 k: __mmask8,
25681 a: __m256d,
25682 b: __m256d,
25683) -> __m256d {
25684 unsafe {
25685 static_assert_uimm_bits!(MASK, 8);
25686 let r = _mm256_shuffle_f64x2::<MASK>(a, b);
25687 transmute(simd_select_bitmask(k, r.as_f64x4(), f64x4::ZERO))
25688 }
25689}
25690
25691#[inline]
25695#[target_feature(enable = "avx512f")]
25696#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25697#[cfg_attr(test, assert_instr(vextractf32x4, IMM8 = 3))]
25698#[rustc_legacy_const_generics(1)]
25699#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25700pub const fn _mm512_extractf32x4_ps<const IMM8: i32>(a: __m512) -> __m128 {
25701 unsafe {
25702 static_assert_uimm_bits!(IMM8, 2);
25703 match IMM8 & 0x3 {
25704 0 => simd_shuffle!(a, _mm512_undefined_ps(), [0, 1, 2, 3]),
25705 1 => simd_shuffle!(a, _mm512_undefined_ps(), [4, 5, 6, 7]),
25706 2 => simd_shuffle!(a, _mm512_undefined_ps(), [8, 9, 10, 11]),
25707 _ => simd_shuffle!(a, _mm512_undefined_ps(), [12, 13, 14, 15]),
25708 }
25709 }
25710}
25711
25712#[inline]
25716#[target_feature(enable = "avx512f")]
25717#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25718#[cfg_attr(test, assert_instr(vextractf32x4, IMM8 = 3))]
25719#[rustc_legacy_const_generics(3)]
25720#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25721pub const fn _mm512_mask_extractf32x4_ps<const IMM8: i32>(
25722 src: __m128,
25723 k: __mmask8,
25724 a: __m512,
25725) -> __m128 {
25726 unsafe {
25727 static_assert_uimm_bits!(IMM8, 2);
25728 let r = _mm512_extractf32x4_ps::<IMM8>(a);
25729 transmute(simd_select_bitmask(k, r.as_f32x4(), src.as_f32x4()))
25730 }
25731}
25732
25733#[inline]
25737#[target_feature(enable = "avx512f")]
25738#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25739#[cfg_attr(test, assert_instr(vextractf32x4, IMM8 = 3))]
25740#[rustc_legacy_const_generics(2)]
25741#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25742pub const fn _mm512_maskz_extractf32x4_ps<const IMM8: i32>(k: __mmask8, a: __m512) -> __m128 {
25743 unsafe {
25744 static_assert_uimm_bits!(IMM8, 2);
25745 let r = _mm512_extractf32x4_ps::<IMM8>(a);
25746 transmute(simd_select_bitmask(k, r.as_f32x4(), f32x4::ZERO))
25747 }
25748}
25749
25750#[inline]
25754#[target_feature(enable = "avx512f,avx512vl")]
25755#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25756#[cfg_attr(
25757 test,
25758 assert_instr(vextract, IMM8 = 1) )]
25760#[rustc_legacy_const_generics(1)]
25761#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25762pub const fn _mm256_extractf32x4_ps<const IMM8: i32>(a: __m256) -> __m128 {
25763 unsafe {
25764 static_assert_uimm_bits!(IMM8, 1);
25765 match IMM8 & 0x1 {
25766 0 => simd_shuffle!(a, _mm256_undefined_ps(), [0, 1, 2, 3]),
25767 _ => simd_shuffle!(a, _mm256_undefined_ps(), [4, 5, 6, 7]),
25768 }
25769 }
25770}
25771
25772#[inline]
25776#[target_feature(enable = "avx512f,avx512vl")]
25777#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25778#[cfg_attr(test, assert_instr(vextractf32x4, IMM8 = 1))]
25779#[rustc_legacy_const_generics(3)]
25780#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25781pub const fn _mm256_mask_extractf32x4_ps<const IMM8: i32>(
25782 src: __m128,
25783 k: __mmask8,
25784 a: __m256,
25785) -> __m128 {
25786 unsafe {
25787 static_assert_uimm_bits!(IMM8, 1);
25788 let r = _mm256_extractf32x4_ps::<IMM8>(a);
25789 transmute(simd_select_bitmask(k, r.as_f32x4(), src.as_f32x4()))
25790 }
25791}
25792
25793#[inline]
25797#[target_feature(enable = "avx512f,avx512vl")]
25798#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25799#[cfg_attr(test, assert_instr(vextractf32x4, IMM8 = 1))]
25800#[rustc_legacy_const_generics(2)]
25801#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25802pub const fn _mm256_maskz_extractf32x4_ps<const IMM8: i32>(k: __mmask8, a: __m256) -> __m128 {
25803 unsafe {
25804 static_assert_uimm_bits!(IMM8, 1);
25805 let r = _mm256_extractf32x4_ps::<IMM8>(a);
25806 transmute(simd_select_bitmask(k, r.as_f32x4(), f32x4::ZERO))
25807 }
25808}
25809
25810#[inline]
25814#[target_feature(enable = "avx512f")]
25815#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25816#[cfg_attr(
25817 test,
25818 assert_instr(vextractf64x4, IMM1 = 1) )]
25820#[rustc_legacy_const_generics(1)]
25821#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25822pub const fn _mm512_extracti64x4_epi64<const IMM1: i32>(a: __m512i) -> __m256i {
25823 unsafe {
25824 static_assert_uimm_bits!(IMM1, 1);
25825 match IMM1 {
25826 0 => simd_shuffle!(a, _mm512_setzero_si512(), [0, 1, 2, 3]),
25827 _ => simd_shuffle!(a, _mm512_setzero_si512(), [4, 5, 6, 7]),
25828 }
25829 }
25830}
25831
25832#[inline]
25836#[target_feature(enable = "avx512f")]
25837#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25838#[cfg_attr(test, assert_instr(vextracti64x4, IMM1 = 1))]
25839#[rustc_legacy_const_generics(3)]
25840#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25841pub const fn _mm512_mask_extracti64x4_epi64<const IMM1: i32>(
25842 src: __m256i,
25843 k: __mmask8,
25844 a: __m512i,
25845) -> __m256i {
25846 unsafe {
25847 static_assert_uimm_bits!(IMM1, 1);
25848 let r = _mm512_extracti64x4_epi64::<IMM1>(a);
25849 transmute(simd_select_bitmask(k, r.as_i64x4(), src.as_i64x4()))
25850 }
25851}
25852
25853#[inline]
25857#[target_feature(enable = "avx512f")]
25858#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25859#[cfg_attr(test, assert_instr(vextracti64x4, IMM1 = 1))]
25860#[rustc_legacy_const_generics(2)]
25861#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25862pub const fn _mm512_maskz_extracti64x4_epi64<const IMM1: i32>(k: __mmask8, a: __m512i) -> __m256i {
25863 unsafe {
25864 static_assert_uimm_bits!(IMM1, 1);
25865 let r = _mm512_extracti64x4_epi64::<IMM1>(a);
25866 transmute(simd_select_bitmask(k, r.as_i64x4(), i64x4::ZERO))
25867 }
25868}
25869
25870#[inline]
25874#[target_feature(enable = "avx512f")]
25875#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25876#[cfg_attr(test, assert_instr(vextractf64x4, IMM8 = 1))]
25877#[rustc_legacy_const_generics(1)]
25878#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25879pub const fn _mm512_extractf64x4_pd<const IMM8: i32>(a: __m512d) -> __m256d {
25880 unsafe {
25881 static_assert_uimm_bits!(IMM8, 1);
25882 match IMM8 & 0x1 {
25883 0 => simd_shuffle!(a, _mm512_undefined_pd(), [0, 1, 2, 3]),
25884 _ => simd_shuffle!(a, _mm512_undefined_pd(), [4, 5, 6, 7]),
25885 }
25886 }
25887}
25888
25889#[inline]
25893#[target_feature(enable = "avx512f")]
25894#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25895#[cfg_attr(test, assert_instr(vextractf64x4, IMM8 = 1))]
25896#[rustc_legacy_const_generics(3)]
25897#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25898pub const fn _mm512_mask_extractf64x4_pd<const IMM8: i32>(
25899 src: __m256d,
25900 k: __mmask8,
25901 a: __m512d,
25902) -> __m256d {
25903 unsafe {
25904 static_assert_uimm_bits!(IMM8, 1);
25905 let r = _mm512_extractf64x4_pd::<IMM8>(a);
25906 transmute(simd_select_bitmask(k, r.as_f64x4(), src.as_f64x4()))
25907 }
25908}
25909
25910#[inline]
25914#[target_feature(enable = "avx512f")]
25915#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25916#[cfg_attr(test, assert_instr(vextractf64x4, IMM8 = 1))]
25917#[rustc_legacy_const_generics(2)]
25918#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25919pub const fn _mm512_maskz_extractf64x4_pd<const IMM8: i32>(k: __mmask8, a: __m512d) -> __m256d {
25920 unsafe {
25921 static_assert_uimm_bits!(IMM8, 1);
25922 let r = _mm512_extractf64x4_pd::<IMM8>(a);
25923 transmute(simd_select_bitmask(k, r.as_f64x4(), f64x4::ZERO))
25924 }
25925}
25926
25927#[inline]
25931#[target_feature(enable = "avx512f")]
25932#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25933#[cfg_attr(
25934 test,
25935 assert_instr(vextractf32x4, IMM2 = 3) )]
25937#[rustc_legacy_const_generics(1)]
25938#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25939pub const fn _mm512_extracti32x4_epi32<const IMM2: i32>(a: __m512i) -> __m128i {
25940 unsafe {
25941 static_assert_uimm_bits!(IMM2, 2);
25942 let a = a.as_i32x16();
25943 let zero = i32x16::ZERO;
25944 let extract: i32x4 = match IMM2 {
25945 0 => simd_shuffle!(a, zero, [0, 1, 2, 3]),
25946 1 => simd_shuffle!(a, zero, [4, 5, 6, 7]),
25947 2 => simd_shuffle!(a, zero, [8, 9, 10, 11]),
25948 _ => simd_shuffle!(a, zero, [12, 13, 14, 15]),
25949 };
25950 transmute(extract)
25951 }
25952}
25953
25954#[inline]
25958#[target_feature(enable = "avx512f")]
25959#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25960#[cfg_attr(test, assert_instr(vextracti32x4, IMM2 = 3))]
25961#[rustc_legacy_const_generics(3)]
25962#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25963pub const fn _mm512_mask_extracti32x4_epi32<const IMM2: i32>(
25964 src: __m128i,
25965 k: __mmask8,
25966 a: __m512i,
25967) -> __m128i {
25968 unsafe {
25969 static_assert_uimm_bits!(IMM2, 2);
25970 let r = _mm512_extracti32x4_epi32::<IMM2>(a);
25971 transmute(simd_select_bitmask(k, r.as_i32x4(), src.as_i32x4()))
25972 }
25973}
25974
25975#[inline]
25979#[target_feature(enable = "avx512f")]
25980#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25981#[cfg_attr(test, assert_instr(vextracti32x4, IMM2 = 3))]
25982#[rustc_legacy_const_generics(2)]
25983#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
25984pub const fn _mm512_maskz_extracti32x4_epi32<const IMM2: i32>(k: __mmask8, a: __m512i) -> __m128i {
25985 unsafe {
25986 static_assert_uimm_bits!(IMM2, 2);
25987 let r = _mm512_extracti32x4_epi32::<IMM2>(a);
25988 transmute(simd_select_bitmask(k, r.as_i32x4(), i32x4::ZERO))
25989 }
25990}
25991
25992#[inline]
25996#[target_feature(enable = "avx512f,avx512vl")]
25997#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
25998#[cfg_attr(
25999 test,
26000 assert_instr(vextract, IMM1 = 1) )]
26002#[rustc_legacy_const_generics(1)]
26003#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26004pub const fn _mm256_extracti32x4_epi32<const IMM1: i32>(a: __m256i) -> __m128i {
26005 unsafe {
26006 static_assert_uimm_bits!(IMM1, 1);
26007 let a = a.as_i32x8();
26008 let zero = i32x8::ZERO;
26009 let extract: i32x4 = match IMM1 {
26010 0 => simd_shuffle!(a, zero, [0, 1, 2, 3]),
26011 _ => simd_shuffle!(a, zero, [4, 5, 6, 7]),
26012 };
26013 transmute(extract)
26014 }
26015}
26016
26017#[inline]
26021#[target_feature(enable = "avx512f,avx512vl")]
26022#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26023#[cfg_attr(test, assert_instr(vextracti32x4, IMM1 = 1))]
26024#[rustc_legacy_const_generics(3)]
26025#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26026pub const fn _mm256_mask_extracti32x4_epi32<const IMM1: i32>(
26027 src: __m128i,
26028 k: __mmask8,
26029 a: __m256i,
26030) -> __m128i {
26031 unsafe {
26032 static_assert_uimm_bits!(IMM1, 1);
26033 let r = _mm256_extracti32x4_epi32::<IMM1>(a);
26034 transmute(simd_select_bitmask(k, r.as_i32x4(), src.as_i32x4()))
26035 }
26036}
26037
26038#[inline]
26042#[target_feature(enable = "avx512f,avx512vl")]
26043#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26044#[cfg_attr(test, assert_instr(vextracti32x4, IMM1 = 1))]
26045#[rustc_legacy_const_generics(2)]
26046#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26047pub const fn _mm256_maskz_extracti32x4_epi32<const IMM1: i32>(k: __mmask8, a: __m256i) -> __m128i {
26048 unsafe {
26049 static_assert_uimm_bits!(IMM1, 1);
26050 let r = _mm256_extracti32x4_epi32::<IMM1>(a);
26051 transmute(simd_select_bitmask(k, r.as_i32x4(), i32x4::ZERO))
26052 }
26053}
26054
26055#[inline]
26059#[target_feature(enable = "avx512f")]
26060#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26061#[cfg_attr(test, assert_instr(vmovsldup))]
26062#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26063pub const fn _mm512_moveldup_ps(a: __m512) -> __m512 {
26064 unsafe {
26065 let r: f32x16 = simd_shuffle!(a, a, [0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14]);
26066 transmute(r)
26067 }
26068}
26069
26070#[inline]
26074#[target_feature(enable = "avx512f")]
26075#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26076#[cfg_attr(test, assert_instr(vmovsldup))]
26077#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26078pub const fn _mm512_mask_moveldup_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
26079 unsafe {
26080 let mov: f32x16 =
26081 simd_shuffle!(a, a, [0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14]);
26082 transmute(simd_select_bitmask(k, mov, src.as_f32x16()))
26083 }
26084}
26085
26086#[inline]
26090#[target_feature(enable = "avx512f")]
26091#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26092#[cfg_attr(test, assert_instr(vmovsldup))]
26093#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26094pub const fn _mm512_maskz_moveldup_ps(k: __mmask16, a: __m512) -> __m512 {
26095 unsafe {
26096 let mov: f32x16 =
26097 simd_shuffle!(a, a, [0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14]);
26098 transmute(simd_select_bitmask(k, mov, f32x16::ZERO))
26099 }
26100}
26101
26102#[inline]
26106#[target_feature(enable = "avx512f,avx512vl")]
26107#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26108#[cfg_attr(test, assert_instr(vmovsldup))]
26109#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26110pub const fn _mm256_mask_moveldup_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
26111 unsafe {
26112 let mov = _mm256_moveldup_ps(a);
26113 transmute(simd_select_bitmask(k, mov.as_f32x8(), src.as_f32x8()))
26114 }
26115}
26116
26117#[inline]
26121#[target_feature(enable = "avx512f,avx512vl")]
26122#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26123#[cfg_attr(test, assert_instr(vmovsldup))]
26124#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26125pub const fn _mm256_maskz_moveldup_ps(k: __mmask8, a: __m256) -> __m256 {
26126 unsafe {
26127 let mov = _mm256_moveldup_ps(a);
26128 transmute(simd_select_bitmask(k, mov.as_f32x8(), f32x8::ZERO))
26129 }
26130}
26131
26132#[inline]
26136#[target_feature(enable = "avx512f,avx512vl")]
26137#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26138#[cfg_attr(test, assert_instr(vmovsldup))]
26139#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26140pub const fn _mm_mask_moveldup_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
26141 unsafe {
26142 let mov = _mm_moveldup_ps(a);
26143 transmute(simd_select_bitmask(k, mov.as_f32x4(), src.as_f32x4()))
26144 }
26145}
26146
26147#[inline]
26151#[target_feature(enable = "avx512f,avx512vl")]
26152#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26153#[cfg_attr(test, assert_instr(vmovsldup))]
26154#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26155pub const fn _mm_maskz_moveldup_ps(k: __mmask8, a: __m128) -> __m128 {
26156 unsafe {
26157 let mov = _mm_moveldup_ps(a);
26158 transmute(simd_select_bitmask(k, mov.as_f32x4(), f32x4::ZERO))
26159 }
26160}
26161
26162#[inline]
26166#[target_feature(enable = "avx512f")]
26167#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26168#[cfg_attr(test, assert_instr(vmovshdup))]
26169#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26170pub const fn _mm512_movehdup_ps(a: __m512) -> __m512 {
26171 unsafe {
26172 let r: f32x16 = simd_shuffle!(a, a, [1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15]);
26173 transmute(r)
26174 }
26175}
26176
26177#[inline]
26181#[target_feature(enable = "avx512f")]
26182#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26183#[cfg_attr(test, assert_instr(vmovshdup))]
26184#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26185pub const fn _mm512_mask_movehdup_ps(src: __m512, k: __mmask16, a: __m512) -> __m512 {
26186 unsafe {
26187 let mov: f32x16 =
26188 simd_shuffle!(a, a, [1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15]);
26189 transmute(simd_select_bitmask(k, mov, src.as_f32x16()))
26190 }
26191}
26192
26193#[inline]
26197#[target_feature(enable = "avx512f")]
26198#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26199#[cfg_attr(test, assert_instr(vmovshdup))]
26200#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26201pub const fn _mm512_maskz_movehdup_ps(k: __mmask16, a: __m512) -> __m512 {
26202 unsafe {
26203 let mov: f32x16 =
26204 simd_shuffle!(a, a, [1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15]);
26205 transmute(simd_select_bitmask(k, mov, f32x16::ZERO))
26206 }
26207}
26208
26209#[inline]
26213#[target_feature(enable = "avx512f,avx512vl")]
26214#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26215#[cfg_attr(test, assert_instr(vmovshdup))]
26216#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26217pub const fn _mm256_mask_movehdup_ps(src: __m256, k: __mmask8, a: __m256) -> __m256 {
26218 unsafe {
26219 let mov = _mm256_movehdup_ps(a);
26220 transmute(simd_select_bitmask(k, mov.as_f32x8(), src.as_f32x8()))
26221 }
26222}
26223
26224#[inline]
26228#[target_feature(enable = "avx512f,avx512vl")]
26229#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26230#[cfg_attr(test, assert_instr(vmovshdup))]
26231#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26232pub const fn _mm256_maskz_movehdup_ps(k: __mmask8, a: __m256) -> __m256 {
26233 unsafe {
26234 let mov = _mm256_movehdup_ps(a);
26235 transmute(simd_select_bitmask(k, mov.as_f32x8(), f32x8::ZERO))
26236 }
26237}
26238
26239#[inline]
26243#[target_feature(enable = "avx512f,avx512vl")]
26244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26245#[cfg_attr(test, assert_instr(vmovshdup))]
26246#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26247pub const fn _mm_mask_movehdup_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
26248 unsafe {
26249 let mov = _mm_movehdup_ps(a);
26250 transmute(simd_select_bitmask(k, mov.as_f32x4(), src.as_f32x4()))
26251 }
26252}
26253
26254#[inline]
26258#[target_feature(enable = "avx512f,avx512vl")]
26259#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26260#[cfg_attr(test, assert_instr(vmovshdup))]
26261#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26262pub const fn _mm_maskz_movehdup_ps(k: __mmask8, a: __m128) -> __m128 {
26263 unsafe {
26264 let mov = _mm_movehdup_ps(a);
26265 transmute(simd_select_bitmask(k, mov.as_f32x4(), f32x4::ZERO))
26266 }
26267}
26268
26269#[inline]
26273#[target_feature(enable = "avx512f")]
26274#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26275#[cfg_attr(test, assert_instr(vmovddup))]
26276#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26277pub const fn _mm512_movedup_pd(a: __m512d) -> __m512d {
26278 unsafe {
26279 let r: f64x8 = simd_shuffle!(a, a, [0, 0, 2, 2, 4, 4, 6, 6]);
26280 transmute(r)
26281 }
26282}
26283
26284#[inline]
26288#[target_feature(enable = "avx512f")]
26289#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26290#[cfg_attr(test, assert_instr(vmovddup))]
26291#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26292pub const fn _mm512_mask_movedup_pd(src: __m512d, k: __mmask8, a: __m512d) -> __m512d {
26293 unsafe {
26294 let mov: f64x8 = simd_shuffle!(a, a, [0, 0, 2, 2, 4, 4, 6, 6]);
26295 transmute(simd_select_bitmask(k, mov, src.as_f64x8()))
26296 }
26297}
26298
26299#[inline]
26303#[target_feature(enable = "avx512f")]
26304#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26305#[cfg_attr(test, assert_instr(vmovddup))]
26306#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26307pub const fn _mm512_maskz_movedup_pd(k: __mmask8, a: __m512d) -> __m512d {
26308 unsafe {
26309 let mov: f64x8 = simd_shuffle!(a, a, [0, 0, 2, 2, 4, 4, 6, 6]);
26310 transmute(simd_select_bitmask(k, mov, f64x8::ZERO))
26311 }
26312}
26313
26314#[inline]
26318#[target_feature(enable = "avx512f,avx512vl")]
26319#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26320#[cfg_attr(test, assert_instr(vmovddup))]
26321#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26322pub const fn _mm256_mask_movedup_pd(src: __m256d, k: __mmask8, a: __m256d) -> __m256d {
26323 unsafe {
26324 let mov = _mm256_movedup_pd(a);
26325 transmute(simd_select_bitmask(k, mov.as_f64x4(), src.as_f64x4()))
26326 }
26327}
26328
26329#[inline]
26333#[target_feature(enable = "avx512f,avx512vl")]
26334#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26335#[cfg_attr(test, assert_instr(vmovddup))]
26336#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26337pub const fn _mm256_maskz_movedup_pd(k: __mmask8, a: __m256d) -> __m256d {
26338 unsafe {
26339 let mov = _mm256_movedup_pd(a);
26340 transmute(simd_select_bitmask(k, mov.as_f64x4(), f64x4::ZERO))
26341 }
26342}
26343
26344#[inline]
26348#[target_feature(enable = "avx512f,avx512vl")]
26349#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26350#[cfg_attr(test, assert_instr(vmovddup))]
26351#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26352pub const fn _mm_mask_movedup_pd(src: __m128d, k: __mmask8, a: __m128d) -> __m128d {
26353 unsafe {
26354 let mov = _mm_movedup_pd(a);
26355 transmute(simd_select_bitmask(k, mov.as_f64x2(), src.as_f64x2()))
26356 }
26357}
26358
26359#[inline]
26363#[target_feature(enable = "avx512f,avx512vl")]
26364#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26365#[cfg_attr(test, assert_instr(vmovddup))]
26366#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26367pub const fn _mm_maskz_movedup_pd(k: __mmask8, a: __m128d) -> __m128d {
26368 unsafe {
26369 let mov = _mm_movedup_pd(a);
26370 transmute(simd_select_bitmask(k, mov.as_f64x2(), f64x2::ZERO))
26371 }
26372}
26373
26374#[inline]
26378#[target_feature(enable = "avx512f")]
26379#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26380#[cfg_attr(test, assert_instr(vinsertf32x4, IMM8 = 2))] #[rustc_legacy_const_generics(2)]
26382#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26383pub const fn _mm512_inserti32x4<const IMM8: i32>(a: __m512i, b: __m128i) -> __m512i {
26384 unsafe {
26385 static_assert_uimm_bits!(IMM8, 2);
26386 let a = a.as_i32x16();
26387 let b = _mm512_castsi128_si512(b).as_i32x16();
26388 let ret: i32x16 = match IMM8 & 0b11 {
26389 0 => {
26390 simd_shuffle!(
26391 a,
26392 b,
26393 [16, 17, 18, 19, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
26394 )
26395 }
26396 1 => {
26397 simd_shuffle!(
26398 a,
26399 b,
26400 [0, 1, 2, 3, 16, 17, 18, 19, 8, 9, 10, 11, 12, 13, 14, 15],
26401 )
26402 }
26403 2 => {
26404 simd_shuffle!(
26405 a,
26406 b,
26407 [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 12, 13, 14, 15],
26408 )
26409 }
26410 _ => {
26411 simd_shuffle!(a, b, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 17, 18, 19])
26412 }
26413 };
26414 transmute(ret)
26415 }
26416}
26417
26418#[inline]
26422#[target_feature(enable = "avx512f")]
26423#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26424#[cfg_attr(test, assert_instr(vinserti32x4, IMM8 = 2))]
26425#[rustc_legacy_const_generics(4)]
26426#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26427pub const fn _mm512_mask_inserti32x4<const IMM8: i32>(
26428 src: __m512i,
26429 k: __mmask16,
26430 a: __m512i,
26431 b: __m128i,
26432) -> __m512i {
26433 unsafe {
26434 static_assert_uimm_bits!(IMM8, 2);
26435 let r = _mm512_inserti32x4::<IMM8>(a, b);
26436 transmute(simd_select_bitmask(k, r.as_i32x16(), src.as_i32x16()))
26437 }
26438}
26439
26440#[inline]
26444#[target_feature(enable = "avx512f")]
26445#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26446#[cfg_attr(test, assert_instr(vinserti32x4, IMM8 = 2))]
26447#[rustc_legacy_const_generics(3)]
26448#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26449pub const fn _mm512_maskz_inserti32x4<const IMM8: i32>(
26450 k: __mmask16,
26451 a: __m512i,
26452 b: __m128i,
26453) -> __m512i {
26454 unsafe {
26455 static_assert_uimm_bits!(IMM8, 2);
26456 let r = _mm512_inserti32x4::<IMM8>(a, b);
26457 transmute(simd_select_bitmask(k, r.as_i32x16(), i32x16::ZERO))
26458 }
26459}
26460
26461#[inline]
26465#[target_feature(enable = "avx512f,avx512vl")]
26466#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26467#[cfg_attr(
26468 test,
26469 assert_instr(vinsert, IMM8 = 1) )]
26471#[rustc_legacy_const_generics(2)]
26472#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26473pub const fn _mm256_inserti32x4<const IMM8: i32>(a: __m256i, b: __m128i) -> __m256i {
26474 unsafe {
26475 static_assert_uimm_bits!(IMM8, 1);
26476 let a = a.as_i32x8();
26477 let b = _mm256_castsi128_si256(b).as_i32x8();
26478 let ret: i32x8 = match IMM8 & 0b1 {
26479 0 => simd_shuffle!(a, b, [8, 9, 10, 11, 4, 5, 6, 7]),
26480 _ => simd_shuffle!(a, b, [0, 1, 2, 3, 8, 9, 10, 11]),
26481 };
26482 transmute(ret)
26483 }
26484}
26485
26486#[inline]
26490#[target_feature(enable = "avx512f,avx512vl")]
26491#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26492#[cfg_attr(test, assert_instr(vinserti32x4, IMM8 = 1))]
26493#[rustc_legacy_const_generics(4)]
26494#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26495pub const fn _mm256_mask_inserti32x4<const IMM8: i32>(
26496 src: __m256i,
26497 k: __mmask8,
26498 a: __m256i,
26499 b: __m128i,
26500) -> __m256i {
26501 unsafe {
26502 static_assert_uimm_bits!(IMM8, 1);
26503 let r = _mm256_inserti32x4::<IMM8>(a, b);
26504 transmute(simd_select_bitmask(k, r.as_i32x8(), src.as_i32x8()))
26505 }
26506}
26507
26508#[inline]
26512#[target_feature(enable = "avx512f,avx512vl")]
26513#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26514#[cfg_attr(test, assert_instr(vinserti32x4, IMM8 = 1))]
26515#[rustc_legacy_const_generics(3)]
26516#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26517pub const fn _mm256_maskz_inserti32x4<const IMM8: i32>(
26518 k: __mmask8,
26519 a: __m256i,
26520 b: __m128i,
26521) -> __m256i {
26522 unsafe {
26523 static_assert_uimm_bits!(IMM8, 1);
26524 let r = _mm256_inserti32x4::<IMM8>(a, b);
26525 transmute(simd_select_bitmask(k, r.as_i32x8(), i32x8::ZERO))
26526 }
26527}
26528
26529#[inline]
26533#[target_feature(enable = "avx512f")]
26534#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26535#[cfg_attr(test, assert_instr(vinsertf64x4, IMM8 = 1))] #[rustc_legacy_const_generics(2)]
26537#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26538pub const fn _mm512_inserti64x4<const IMM8: i32>(a: __m512i, b: __m256i) -> __m512i {
26539 unsafe {
26540 static_assert_uimm_bits!(IMM8, 1);
26541 let b = _mm512_castsi256_si512(b);
26542 match IMM8 & 0b1 {
26543 0 => simd_shuffle!(a, b, [8, 9, 10, 11, 4, 5, 6, 7]),
26544 _ => simd_shuffle!(a, b, [0, 1, 2, 3, 8, 9, 10, 11]),
26545 }
26546 }
26547}
26548
26549#[inline]
26553#[target_feature(enable = "avx512f")]
26554#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26555#[cfg_attr(test, assert_instr(vinserti64x4, IMM8 = 1))]
26556#[rustc_legacy_const_generics(4)]
26557#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26558pub const fn _mm512_mask_inserti64x4<const IMM8: i32>(
26559 src: __m512i,
26560 k: __mmask8,
26561 a: __m512i,
26562 b: __m256i,
26563) -> __m512i {
26564 unsafe {
26565 static_assert_uimm_bits!(IMM8, 1);
26566 let r = _mm512_inserti64x4::<IMM8>(a, b);
26567 transmute(simd_select_bitmask(k, r.as_i64x8(), src.as_i64x8()))
26568 }
26569}
26570
26571#[inline]
26575#[target_feature(enable = "avx512f")]
26576#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26577#[cfg_attr(test, assert_instr(vinserti64x4, IMM8 = 1))]
26578#[rustc_legacy_const_generics(3)]
26579#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26580pub const fn _mm512_maskz_inserti64x4<const IMM8: i32>(
26581 k: __mmask8,
26582 a: __m512i,
26583 b: __m256i,
26584) -> __m512i {
26585 unsafe {
26586 static_assert_uimm_bits!(IMM8, 1);
26587 let r = _mm512_inserti64x4::<IMM8>(a, b);
26588 transmute(simd_select_bitmask(k, r.as_i64x8(), i64x8::ZERO))
26589 }
26590}
26591
26592#[inline]
26596#[target_feature(enable = "avx512f")]
26597#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26598#[cfg_attr(test, assert_instr(vinsertf32x4, IMM8 = 2))]
26599#[rustc_legacy_const_generics(2)]
26600#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26601pub const fn _mm512_insertf32x4<const IMM8: i32>(a: __m512, b: __m128) -> __m512 {
26602 unsafe {
26603 static_assert_uimm_bits!(IMM8, 2);
26604 let b = _mm512_castps128_ps512(b);
26605 match IMM8 & 0b11 {
26606 0 => {
26607 simd_shuffle!(
26608 a,
26609 b,
26610 [16, 17, 18, 19, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
26611 )
26612 }
26613 1 => {
26614 simd_shuffle!(
26615 a,
26616 b,
26617 [0, 1, 2, 3, 16, 17, 18, 19, 8, 9, 10, 11, 12, 13, 14, 15],
26618 )
26619 }
26620 2 => {
26621 simd_shuffle!(
26622 a,
26623 b,
26624 [0, 1, 2, 3, 4, 5, 6, 7, 16, 17, 18, 19, 12, 13, 14, 15],
26625 )
26626 }
26627 _ => {
26628 simd_shuffle!(a, b, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 16, 17, 18, 19])
26629 }
26630 }
26631 }
26632}
26633
26634#[inline]
26638#[target_feature(enable = "avx512f")]
26639#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26640#[cfg_attr(test, assert_instr(vinsertf32x4, IMM8 = 2))]
26641#[rustc_legacy_const_generics(4)]
26642#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26643pub const fn _mm512_mask_insertf32x4<const IMM8: i32>(
26644 src: __m512,
26645 k: __mmask16,
26646 a: __m512,
26647 b: __m128,
26648) -> __m512 {
26649 unsafe {
26650 static_assert_uimm_bits!(IMM8, 2);
26651 let r = _mm512_insertf32x4::<IMM8>(a, b);
26652 transmute(simd_select_bitmask(k, r.as_f32x16(), src.as_f32x16()))
26653 }
26654}
26655
26656#[inline]
26660#[target_feature(enable = "avx512f")]
26661#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26662#[cfg_attr(test, assert_instr(vinsertf32x4, IMM8 = 2))]
26663#[rustc_legacy_const_generics(3)]
26664#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26665pub const fn _mm512_maskz_insertf32x4<const IMM8: i32>(
26666 k: __mmask16,
26667 a: __m512,
26668 b: __m128,
26669) -> __m512 {
26670 unsafe {
26671 static_assert_uimm_bits!(IMM8, 2);
26672 let r = _mm512_insertf32x4::<IMM8>(a, b);
26673 transmute(simd_select_bitmask(k, r.as_f32x16(), f32x16::ZERO))
26674 }
26675}
26676
26677#[inline]
26681#[target_feature(enable = "avx512f,avx512vl")]
26682#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26683#[cfg_attr(
26684 test,
26685 assert_instr(vinsert, IMM8 = 1) )]
26687#[rustc_legacy_const_generics(2)]
26688#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26689pub const fn _mm256_insertf32x4<const IMM8: i32>(a: __m256, b: __m128) -> __m256 {
26690 unsafe {
26691 static_assert_uimm_bits!(IMM8, 1);
26692 let b = _mm256_castps128_ps256(b);
26693 match IMM8 & 0b1 {
26694 0 => simd_shuffle!(a, b, [8, 9, 10, 11, 4, 5, 6, 7]),
26695 _ => simd_shuffle!(a, b, [0, 1, 2, 3, 8, 9, 10, 11]),
26696 }
26697 }
26698}
26699
26700#[inline]
26704#[target_feature(enable = "avx512f,avx512vl")]
26705#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26706#[cfg_attr(test, assert_instr(vinsertf32x4, IMM8 = 1))]
26707#[rustc_legacy_const_generics(4)]
26708#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26709pub const fn _mm256_mask_insertf32x4<const IMM8: i32>(
26710 src: __m256,
26711 k: __mmask8,
26712 a: __m256,
26713 b: __m128,
26714) -> __m256 {
26715 unsafe {
26716 static_assert_uimm_bits!(IMM8, 1);
26717 let r = _mm256_insertf32x4::<IMM8>(a, b);
26718 transmute(simd_select_bitmask(k, r.as_f32x8(), src.as_f32x8()))
26719 }
26720}
26721
26722#[inline]
26726#[target_feature(enable = "avx512f,avx512vl")]
26727#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26728#[cfg_attr(test, assert_instr(vinsertf32x4, IMM8 = 1))]
26729#[rustc_legacy_const_generics(3)]
26730#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26731pub const fn _mm256_maskz_insertf32x4<const IMM8: i32>(
26732 k: __mmask8,
26733 a: __m256,
26734 b: __m128,
26735) -> __m256 {
26736 unsafe {
26737 static_assert_uimm_bits!(IMM8, 1);
26738 let r = _mm256_insertf32x4::<IMM8>(a, b);
26739 transmute(simd_select_bitmask(k, r.as_f32x8(), f32x8::ZERO))
26740 }
26741}
26742
26743#[inline]
26747#[target_feature(enable = "avx512f")]
26748#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26749#[cfg_attr(test, assert_instr(vinsertf64x4, IMM8 = 1))]
26750#[rustc_legacy_const_generics(2)]
26751#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26752pub const fn _mm512_insertf64x4<const IMM8: i32>(a: __m512d, b: __m256d) -> __m512d {
26753 unsafe {
26754 static_assert_uimm_bits!(IMM8, 1);
26755 let b = _mm512_castpd256_pd512(b);
26756 match IMM8 & 0b1 {
26757 0 => simd_shuffle!(a, b, [8, 9, 10, 11, 4, 5, 6, 7]),
26758 _ => simd_shuffle!(a, b, [0, 1, 2, 3, 8, 9, 10, 11]),
26759 }
26760 }
26761}
26762
26763#[inline]
26767#[target_feature(enable = "avx512f")]
26768#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26769#[cfg_attr(test, assert_instr(vinsertf64x4, IMM8 = 1))]
26770#[rustc_legacy_const_generics(4)]
26771#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26772pub const fn _mm512_mask_insertf64x4<const IMM8: i32>(
26773 src: __m512d,
26774 k: __mmask8,
26775 a: __m512d,
26776 b: __m256d,
26777) -> __m512d {
26778 unsafe {
26779 static_assert_uimm_bits!(IMM8, 1);
26780 let r = _mm512_insertf64x4::<IMM8>(a, b);
26781 transmute(simd_select_bitmask(k, r.as_f64x8(), src.as_f64x8()))
26782 }
26783}
26784
26785#[inline]
26789#[target_feature(enable = "avx512f")]
26790#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26791#[cfg_attr(test, assert_instr(vinsertf64x4, IMM8 = 1))]
26792#[rustc_legacy_const_generics(3)]
26793#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26794pub const fn _mm512_maskz_insertf64x4<const IMM8: i32>(
26795 k: __mmask8,
26796 a: __m512d,
26797 b: __m256d,
26798) -> __m512d {
26799 unsafe {
26800 static_assert_uimm_bits!(IMM8, 1);
26801 let r = _mm512_insertf64x4::<IMM8>(a, b);
26802 transmute(simd_select_bitmask(k, r.as_f64x8(), f64x8::ZERO))
26803 }
26804}
26805
26806#[inline]
26810#[target_feature(enable = "avx512f")]
26811#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26812#[cfg_attr(test, assert_instr(vunpckhps))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26814pub const fn _mm512_unpackhi_epi32(a: __m512i, b: __m512i) -> __m512i {
26815 unsafe {
26816 let a = a.as_i32x16();
26817 let b = b.as_i32x16();
26818 #[rustfmt::skip]
26819 let r: i32x16 = simd_shuffle!(
26820 a, b,
26821 [ 2, 18, 3, 19,
26822 2 + 4, 18 + 4, 3 + 4, 19 + 4,
26823 2 + 8, 18 + 8, 3 + 8, 19 + 8,
26824 2 + 12, 18 + 12, 3 + 12, 19 + 12],
26825 );
26826 transmute(r)
26827 }
26828}
26829
26830#[inline]
26834#[target_feature(enable = "avx512f")]
26835#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26836#[cfg_attr(test, assert_instr(vpunpckhdq))]
26837#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26838pub const fn _mm512_mask_unpackhi_epi32(
26839 src: __m512i,
26840 k: __mmask16,
26841 a: __m512i,
26842 b: __m512i,
26843) -> __m512i {
26844 unsafe {
26845 let unpackhi = _mm512_unpackhi_epi32(a, b).as_i32x16();
26846 transmute(simd_select_bitmask(k, unpackhi, src.as_i32x16()))
26847 }
26848}
26849
26850#[inline]
26854#[target_feature(enable = "avx512f")]
26855#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26856#[cfg_attr(test, assert_instr(vpunpckhdq))]
26857#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26858pub const fn _mm512_maskz_unpackhi_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
26859 unsafe {
26860 let unpackhi = _mm512_unpackhi_epi32(a, b).as_i32x16();
26861 transmute(simd_select_bitmask(k, unpackhi, i32x16::ZERO))
26862 }
26863}
26864
26865#[inline]
26869#[target_feature(enable = "avx512f,avx512vl")]
26870#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26871#[cfg_attr(test, assert_instr(vpunpckhdq))]
26872#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26873pub const fn _mm256_mask_unpackhi_epi32(
26874 src: __m256i,
26875 k: __mmask8,
26876 a: __m256i,
26877 b: __m256i,
26878) -> __m256i {
26879 unsafe {
26880 let unpackhi = _mm256_unpackhi_epi32(a, b).as_i32x8();
26881 transmute(simd_select_bitmask(k, unpackhi, src.as_i32x8()))
26882 }
26883}
26884
26885#[inline]
26889#[target_feature(enable = "avx512f,avx512vl")]
26890#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26891#[cfg_attr(test, assert_instr(vpunpckhdq))]
26892#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26893pub const fn _mm256_maskz_unpackhi_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
26894 unsafe {
26895 let unpackhi = _mm256_unpackhi_epi32(a, b).as_i32x8();
26896 transmute(simd_select_bitmask(k, unpackhi, i32x8::ZERO))
26897 }
26898}
26899
26900#[inline]
26904#[target_feature(enable = "avx512f,avx512vl")]
26905#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26906#[cfg_attr(test, assert_instr(vpunpckhdq))]
26907#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26908pub const fn _mm_mask_unpackhi_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
26909 unsafe {
26910 let unpackhi = _mm_unpackhi_epi32(a, b).as_i32x4();
26911 transmute(simd_select_bitmask(k, unpackhi, src.as_i32x4()))
26912 }
26913}
26914
26915#[inline]
26919#[target_feature(enable = "avx512f,avx512vl")]
26920#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26921#[cfg_attr(test, assert_instr(vpunpckhdq))]
26922#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26923pub const fn _mm_maskz_unpackhi_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
26924 unsafe {
26925 let unpackhi = _mm_unpackhi_epi32(a, b).as_i32x4();
26926 transmute(simd_select_bitmask(k, unpackhi, i32x4::ZERO))
26927 }
26928}
26929
26930#[inline]
26934#[target_feature(enable = "avx512f")]
26935#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26936#[cfg_attr(test, assert_instr(vunpckhpd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26938pub const fn _mm512_unpackhi_epi64(a: __m512i, b: __m512i) -> __m512i {
26939 unsafe { simd_shuffle!(a, b, [1, 9, 1 + 2, 9 + 2, 1 + 4, 9 + 4, 1 + 6, 9 + 6]) }
26940}
26941
26942#[inline]
26946#[target_feature(enable = "avx512f")]
26947#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26948#[cfg_attr(test, assert_instr(vpunpckhqdq))]
26949#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26950pub const fn _mm512_mask_unpackhi_epi64(
26951 src: __m512i,
26952 k: __mmask8,
26953 a: __m512i,
26954 b: __m512i,
26955) -> __m512i {
26956 unsafe {
26957 let unpackhi = _mm512_unpackhi_epi64(a, b).as_i64x8();
26958 transmute(simd_select_bitmask(k, unpackhi, src.as_i64x8()))
26959 }
26960}
26961
26962#[inline]
26966#[target_feature(enable = "avx512f")]
26967#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26968#[cfg_attr(test, assert_instr(vpunpckhqdq))]
26969#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26970pub const fn _mm512_maskz_unpackhi_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
26971 unsafe {
26972 let unpackhi = _mm512_unpackhi_epi64(a, b).as_i64x8();
26973 transmute(simd_select_bitmask(k, unpackhi, i64x8::ZERO))
26974 }
26975}
26976
26977#[inline]
26981#[target_feature(enable = "avx512f,avx512vl")]
26982#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
26983#[cfg_attr(test, assert_instr(vpunpckhqdq))]
26984#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
26985pub const fn _mm256_mask_unpackhi_epi64(
26986 src: __m256i,
26987 k: __mmask8,
26988 a: __m256i,
26989 b: __m256i,
26990) -> __m256i {
26991 unsafe {
26992 let unpackhi = _mm256_unpackhi_epi64(a, b).as_i64x4();
26993 transmute(simd_select_bitmask(k, unpackhi, src.as_i64x4()))
26994 }
26995}
26996
26997#[inline]
27001#[target_feature(enable = "avx512f,avx512vl")]
27002#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27003#[cfg_attr(test, assert_instr(vpunpckhqdq))]
27004#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27005pub const fn _mm256_maskz_unpackhi_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
27006 unsafe {
27007 let unpackhi = _mm256_unpackhi_epi64(a, b).as_i64x4();
27008 transmute(simd_select_bitmask(k, unpackhi, i64x4::ZERO))
27009 }
27010}
27011
27012#[inline]
27016#[target_feature(enable = "avx512f,avx512vl")]
27017#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27018#[cfg_attr(test, assert_instr(vpunpckhqdq))]
27019#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27020pub const fn _mm_mask_unpackhi_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
27021 unsafe {
27022 let unpackhi = _mm_unpackhi_epi64(a, b).as_i64x2();
27023 transmute(simd_select_bitmask(k, unpackhi, src.as_i64x2()))
27024 }
27025}
27026
27027#[inline]
27031#[target_feature(enable = "avx512f,avx512vl")]
27032#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27033#[cfg_attr(test, assert_instr(vpunpckhqdq))]
27034#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27035pub const fn _mm_maskz_unpackhi_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
27036 unsafe {
27037 let unpackhi = _mm_unpackhi_epi64(a, b).as_i64x2();
27038 transmute(simd_select_bitmask(k, unpackhi, i64x2::ZERO))
27039 }
27040}
27041
27042#[inline]
27046#[target_feature(enable = "avx512f")]
27047#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27048#[cfg_attr(test, assert_instr(vunpckhps))]
27049#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27050pub const fn _mm512_unpackhi_ps(a: __m512, b: __m512) -> __m512 {
27051 unsafe {
27052 #[rustfmt::skip]
27053 simd_shuffle!(
27054 a, b,
27055 [ 2, 18, 3, 19,
27056 2 + 4, 18 + 4, 3 + 4, 19 + 4,
27057 2 + 8, 18 + 8, 3 + 8, 19 + 8,
27058 2 + 12, 18 + 12, 3 + 12, 19 + 12],
27059 )
27060 }
27061}
27062
27063#[inline]
27067#[target_feature(enable = "avx512f")]
27068#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27069#[cfg_attr(test, assert_instr(vunpckhps))]
27070#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27071pub const fn _mm512_mask_unpackhi_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
27072 unsafe {
27073 let unpackhi = _mm512_unpackhi_ps(a, b).as_f32x16();
27074 transmute(simd_select_bitmask(k, unpackhi, src.as_f32x16()))
27075 }
27076}
27077
27078#[inline]
27082#[target_feature(enable = "avx512f")]
27083#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27084#[cfg_attr(test, assert_instr(vunpckhps))]
27085#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27086pub const fn _mm512_maskz_unpackhi_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
27087 unsafe {
27088 let unpackhi = _mm512_unpackhi_ps(a, b).as_f32x16();
27089 transmute(simd_select_bitmask(k, unpackhi, f32x16::ZERO))
27090 }
27091}
27092
27093#[inline]
27097#[target_feature(enable = "avx512f,avx512vl")]
27098#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27099#[cfg_attr(test, assert_instr(vunpckhps))]
27100#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27101pub const fn _mm256_mask_unpackhi_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
27102 unsafe {
27103 let unpackhi = _mm256_unpackhi_ps(a, b).as_f32x8();
27104 transmute(simd_select_bitmask(k, unpackhi, src.as_f32x8()))
27105 }
27106}
27107
27108#[inline]
27112#[target_feature(enable = "avx512f,avx512vl")]
27113#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27114#[cfg_attr(test, assert_instr(vunpckhps))]
27115#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27116pub const fn _mm256_maskz_unpackhi_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
27117 unsafe {
27118 let unpackhi = _mm256_unpackhi_ps(a, b).as_f32x8();
27119 transmute(simd_select_bitmask(k, unpackhi, f32x8::ZERO))
27120 }
27121}
27122
27123#[inline]
27127#[target_feature(enable = "avx512f,avx512vl")]
27128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27129#[cfg_attr(test, assert_instr(vunpckhps))]
27130#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27131pub const fn _mm_mask_unpackhi_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
27132 unsafe {
27133 let unpackhi = _mm_unpackhi_ps(a, b).as_f32x4();
27134 transmute(simd_select_bitmask(k, unpackhi, src.as_f32x4()))
27135 }
27136}
27137
27138#[inline]
27142#[target_feature(enable = "avx512f,avx512vl")]
27143#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27144#[cfg_attr(test, assert_instr(vunpckhps))]
27145#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27146pub const fn _mm_maskz_unpackhi_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
27147 unsafe {
27148 let unpackhi = _mm_unpackhi_ps(a, b).as_f32x4();
27149 transmute(simd_select_bitmask(k, unpackhi, f32x4::ZERO))
27150 }
27151}
27152
27153#[inline]
27157#[target_feature(enable = "avx512f")]
27158#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27159#[cfg_attr(test, assert_instr(vunpckhpd))]
27160#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27161pub const fn _mm512_unpackhi_pd(a: __m512d, b: __m512d) -> __m512d {
27162 unsafe { simd_shuffle!(a, b, [1, 9, 1 + 2, 9 + 2, 1 + 4, 9 + 4, 1 + 6, 9 + 6]) }
27163}
27164
27165#[inline]
27169#[target_feature(enable = "avx512f")]
27170#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27171#[cfg_attr(test, assert_instr(vunpckhpd))]
27172#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27173pub const fn _mm512_mask_unpackhi_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
27174 unsafe {
27175 let unpackhi = _mm512_unpackhi_pd(a, b).as_f64x8();
27176 transmute(simd_select_bitmask(k, unpackhi, src.as_f64x8()))
27177 }
27178}
27179
27180#[inline]
27184#[target_feature(enable = "avx512f")]
27185#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27186#[cfg_attr(test, assert_instr(vunpckhpd))]
27187#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27188pub const fn _mm512_maskz_unpackhi_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
27189 unsafe {
27190 let unpackhi = _mm512_unpackhi_pd(a, b).as_f64x8();
27191 transmute(simd_select_bitmask(k, unpackhi, f64x8::ZERO))
27192 }
27193}
27194
27195#[inline]
27199#[target_feature(enable = "avx512f,avx512vl")]
27200#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27201#[cfg_attr(test, assert_instr(vunpckhpd))]
27202#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27203pub const fn _mm256_mask_unpackhi_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
27204 unsafe {
27205 let unpackhi = _mm256_unpackhi_pd(a, b).as_f64x4();
27206 transmute(simd_select_bitmask(k, unpackhi, src.as_f64x4()))
27207 }
27208}
27209
27210#[inline]
27214#[target_feature(enable = "avx512f,avx512vl")]
27215#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27216#[cfg_attr(test, assert_instr(vunpckhpd))]
27217#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27218pub const fn _mm256_maskz_unpackhi_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
27219 unsafe {
27220 let unpackhi = _mm256_unpackhi_pd(a, b).as_f64x4();
27221 transmute(simd_select_bitmask(k, unpackhi, f64x4::ZERO))
27222 }
27223}
27224
27225#[inline]
27229#[target_feature(enable = "avx512f,avx512vl")]
27230#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27231#[cfg_attr(test, assert_instr(vunpckhpd))]
27232#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27233pub const fn _mm_mask_unpackhi_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
27234 unsafe {
27235 let unpackhi = _mm_unpackhi_pd(a, b).as_f64x2();
27236 transmute(simd_select_bitmask(k, unpackhi, src.as_f64x2()))
27237 }
27238}
27239
27240#[inline]
27244#[target_feature(enable = "avx512f,avx512vl")]
27245#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27246#[cfg_attr(test, assert_instr(vunpckhpd))]
27247#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27248pub const fn _mm_maskz_unpackhi_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
27249 unsafe {
27250 let unpackhi = _mm_unpackhi_pd(a, b).as_f64x2();
27251 transmute(simd_select_bitmask(k, unpackhi, f64x2::ZERO))
27252 }
27253}
27254
27255#[inline]
27259#[target_feature(enable = "avx512f")]
27260#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27261#[cfg_attr(test, assert_instr(vunpcklps))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27263pub const fn _mm512_unpacklo_epi32(a: __m512i, b: __m512i) -> __m512i {
27264 unsafe {
27265 let a = a.as_i32x16();
27266 let b = b.as_i32x16();
27267 #[rustfmt::skip]
27268 let r: i32x16 = simd_shuffle!(
27269 a, b,
27270 [ 0, 16, 1, 17,
27271 0 + 4, 16 + 4, 1 + 4, 17 + 4,
27272 0 + 8, 16 + 8, 1 + 8, 17 + 8,
27273 0 + 12, 16 + 12, 1 + 12, 17 + 12],
27274 );
27275 transmute(r)
27276 }
27277}
27278
27279#[inline]
27283#[target_feature(enable = "avx512f")]
27284#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27285#[cfg_attr(test, assert_instr(vpunpckldq))]
27286#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27287pub const fn _mm512_mask_unpacklo_epi32(
27288 src: __m512i,
27289 k: __mmask16,
27290 a: __m512i,
27291 b: __m512i,
27292) -> __m512i {
27293 unsafe {
27294 let unpacklo = _mm512_unpacklo_epi32(a, b).as_i32x16();
27295 transmute(simd_select_bitmask(k, unpacklo, src.as_i32x16()))
27296 }
27297}
27298
27299#[inline]
27303#[target_feature(enable = "avx512f")]
27304#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27305#[cfg_attr(test, assert_instr(vpunpckldq))]
27306#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27307pub const fn _mm512_maskz_unpacklo_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
27308 unsafe {
27309 let unpacklo = _mm512_unpacklo_epi32(a, b).as_i32x16();
27310 transmute(simd_select_bitmask(k, unpacklo, i32x16::ZERO))
27311 }
27312}
27313
27314#[inline]
27318#[target_feature(enable = "avx512f,avx512vl")]
27319#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27320#[cfg_attr(test, assert_instr(vpunpckldq))]
27321#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27322pub const fn _mm256_mask_unpacklo_epi32(
27323 src: __m256i,
27324 k: __mmask8,
27325 a: __m256i,
27326 b: __m256i,
27327) -> __m256i {
27328 unsafe {
27329 let unpacklo = _mm256_unpacklo_epi32(a, b).as_i32x8();
27330 transmute(simd_select_bitmask(k, unpacklo, src.as_i32x8()))
27331 }
27332}
27333
27334#[inline]
27338#[target_feature(enable = "avx512f,avx512vl")]
27339#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27340#[cfg_attr(test, assert_instr(vpunpckldq))]
27341#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27342pub const fn _mm256_maskz_unpacklo_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
27343 unsafe {
27344 let unpacklo = _mm256_unpacklo_epi32(a, b).as_i32x8();
27345 transmute(simd_select_bitmask(k, unpacklo, i32x8::ZERO))
27346 }
27347}
27348
27349#[inline]
27353#[target_feature(enable = "avx512f,avx512vl")]
27354#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27355#[cfg_attr(test, assert_instr(vpunpckldq))]
27356#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27357pub const fn _mm_mask_unpacklo_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
27358 unsafe {
27359 let unpacklo = _mm_unpacklo_epi32(a, b).as_i32x4();
27360 transmute(simd_select_bitmask(k, unpacklo, src.as_i32x4()))
27361 }
27362}
27363
27364#[inline]
27368#[target_feature(enable = "avx512f,avx512vl")]
27369#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27370#[cfg_attr(test, assert_instr(vpunpckldq))]
27371#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27372pub const fn _mm_maskz_unpacklo_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
27373 unsafe {
27374 let unpacklo = _mm_unpacklo_epi32(a, b).as_i32x4();
27375 transmute(simd_select_bitmask(k, unpacklo, i32x4::ZERO))
27376 }
27377}
27378
27379#[inline]
27383#[target_feature(enable = "avx512f")]
27384#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27385#[cfg_attr(test, assert_instr(vunpcklpd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27387pub const fn _mm512_unpacklo_epi64(a: __m512i, b: __m512i) -> __m512i {
27388 unsafe { simd_shuffle!(a, b, [0, 8, 0 + 2, 8 + 2, 0 + 4, 8 + 4, 0 + 6, 8 + 6]) }
27389}
27390
27391#[inline]
27395#[target_feature(enable = "avx512f")]
27396#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27397#[cfg_attr(test, assert_instr(vpunpcklqdq))]
27398#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27399pub const fn _mm512_mask_unpacklo_epi64(
27400 src: __m512i,
27401 k: __mmask8,
27402 a: __m512i,
27403 b: __m512i,
27404) -> __m512i {
27405 unsafe {
27406 let unpacklo = _mm512_unpacklo_epi64(a, b).as_i64x8();
27407 transmute(simd_select_bitmask(k, unpacklo, src.as_i64x8()))
27408 }
27409}
27410
27411#[inline]
27415#[target_feature(enable = "avx512f")]
27416#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27417#[cfg_attr(test, assert_instr(vpunpcklqdq))]
27418#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27419pub const fn _mm512_maskz_unpacklo_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
27420 unsafe {
27421 let unpacklo = _mm512_unpacklo_epi64(a, b).as_i64x8();
27422 transmute(simd_select_bitmask(k, unpacklo, i64x8::ZERO))
27423 }
27424}
27425
27426#[inline]
27430#[target_feature(enable = "avx512f,avx512vl")]
27431#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27432#[cfg_attr(test, assert_instr(vpunpcklqdq))]
27433#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27434pub const fn _mm256_mask_unpacklo_epi64(
27435 src: __m256i,
27436 k: __mmask8,
27437 a: __m256i,
27438 b: __m256i,
27439) -> __m256i {
27440 unsafe {
27441 let unpacklo = _mm256_unpacklo_epi64(a, b).as_i64x4();
27442 transmute(simd_select_bitmask(k, unpacklo, src.as_i64x4()))
27443 }
27444}
27445
27446#[inline]
27450#[target_feature(enable = "avx512f,avx512vl")]
27451#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27452#[cfg_attr(test, assert_instr(vpunpcklqdq))]
27453#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27454pub const fn _mm256_maskz_unpacklo_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
27455 unsafe {
27456 let unpacklo = _mm256_unpacklo_epi64(a, b).as_i64x4();
27457 transmute(simd_select_bitmask(k, unpacklo, i64x4::ZERO))
27458 }
27459}
27460
27461#[inline]
27465#[target_feature(enable = "avx512f,avx512vl")]
27466#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27467#[cfg_attr(test, assert_instr(vpunpcklqdq))]
27468#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27469pub const fn _mm_mask_unpacklo_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
27470 unsafe {
27471 let unpacklo = _mm_unpacklo_epi64(a, b).as_i64x2();
27472 transmute(simd_select_bitmask(k, unpacklo, src.as_i64x2()))
27473 }
27474}
27475
27476#[inline]
27480#[target_feature(enable = "avx512f,avx512vl")]
27481#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27482#[cfg_attr(test, assert_instr(vpunpcklqdq))]
27483#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27484pub const fn _mm_maskz_unpacklo_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
27485 unsafe {
27486 let unpacklo = _mm_unpacklo_epi64(a, b).as_i64x2();
27487 transmute(simd_select_bitmask(k, unpacklo, i64x2::ZERO))
27488 }
27489}
27490
27491#[inline]
27495#[target_feature(enable = "avx512f")]
27496#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27497#[cfg_attr(test, assert_instr(vunpcklps))]
27498#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27499pub const fn _mm512_unpacklo_ps(a: __m512, b: __m512) -> __m512 {
27500 unsafe {
27501 #[rustfmt::skip]
27502 simd_shuffle!(a, b,
27503 [ 0, 16, 1, 17,
27504 0 + 4, 16 + 4, 1 + 4, 17 + 4,
27505 0 + 8, 16 + 8, 1 + 8, 17 + 8,
27506 0 + 12, 16 + 12, 1 + 12, 17 + 12],
27507 )
27508 }
27509}
27510
27511#[inline]
27515#[target_feature(enable = "avx512f")]
27516#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27517#[cfg_attr(test, assert_instr(vunpcklps))]
27518#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27519pub const fn _mm512_mask_unpacklo_ps(src: __m512, k: __mmask16, a: __m512, b: __m512) -> __m512 {
27520 unsafe {
27521 let unpacklo = _mm512_unpacklo_ps(a, b).as_f32x16();
27522 transmute(simd_select_bitmask(k, unpacklo, src.as_f32x16()))
27523 }
27524}
27525
27526#[inline]
27530#[target_feature(enable = "avx512f")]
27531#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27532#[cfg_attr(test, assert_instr(vunpcklps))]
27533#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27534pub const fn _mm512_maskz_unpacklo_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
27535 unsafe {
27536 let unpacklo = _mm512_unpacklo_ps(a, b).as_f32x16();
27537 transmute(simd_select_bitmask(k, unpacklo, f32x16::ZERO))
27538 }
27539}
27540
27541#[inline]
27545#[target_feature(enable = "avx512f,avx512vl")]
27546#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27547#[cfg_attr(test, assert_instr(vunpcklps))]
27548#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27549pub const fn _mm256_mask_unpacklo_ps(src: __m256, k: __mmask8, a: __m256, b: __m256) -> __m256 {
27550 unsafe {
27551 let unpacklo = _mm256_unpacklo_ps(a, b).as_f32x8();
27552 transmute(simd_select_bitmask(k, unpacklo, src.as_f32x8()))
27553 }
27554}
27555
27556#[inline]
27560#[target_feature(enable = "avx512f,avx512vl")]
27561#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27562#[cfg_attr(test, assert_instr(vunpcklps))]
27563#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27564pub const fn _mm256_maskz_unpacklo_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
27565 unsafe {
27566 let unpacklo = _mm256_unpacklo_ps(a, b).as_f32x8();
27567 transmute(simd_select_bitmask(k, unpacklo, f32x8::ZERO))
27568 }
27569}
27570
27571#[inline]
27575#[target_feature(enable = "avx512f,avx512vl")]
27576#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27577#[cfg_attr(test, assert_instr(vunpcklps))]
27578#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27579pub const fn _mm_mask_unpacklo_ps(src: __m128, k: __mmask8, a: __m128, b: __m128) -> __m128 {
27580 unsafe {
27581 let unpacklo = _mm_unpacklo_ps(a, b).as_f32x4();
27582 transmute(simd_select_bitmask(k, unpacklo, src.as_f32x4()))
27583 }
27584}
27585
27586#[inline]
27590#[target_feature(enable = "avx512f,avx512vl")]
27591#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27592#[cfg_attr(test, assert_instr(vunpcklps))]
27593#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27594pub const fn _mm_maskz_unpacklo_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
27595 unsafe {
27596 let unpacklo = _mm_unpacklo_ps(a, b).as_f32x4();
27597 transmute(simd_select_bitmask(k, unpacklo, f32x4::ZERO))
27598 }
27599}
27600
27601#[inline]
27605#[target_feature(enable = "avx512f")]
27606#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27607#[cfg_attr(test, assert_instr(vunpcklpd))]
27608#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27609pub const fn _mm512_unpacklo_pd(a: __m512d, b: __m512d) -> __m512d {
27610 unsafe { simd_shuffle!(a, b, [0, 8, 0 + 2, 8 + 2, 0 + 4, 8 + 4, 0 + 6, 8 + 6]) }
27611}
27612
27613#[inline]
27617#[target_feature(enable = "avx512f")]
27618#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27619#[cfg_attr(test, assert_instr(vunpcklpd))]
27620#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27621pub const fn _mm512_mask_unpacklo_pd(src: __m512d, k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
27622 unsafe {
27623 let unpacklo = _mm512_unpacklo_pd(a, b).as_f64x8();
27624 transmute(simd_select_bitmask(k, unpacklo, src.as_f64x8()))
27625 }
27626}
27627
27628#[inline]
27632#[target_feature(enable = "avx512f")]
27633#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27634#[cfg_attr(test, assert_instr(vunpcklpd))]
27635#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27636pub const fn _mm512_maskz_unpacklo_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
27637 unsafe {
27638 let unpacklo = _mm512_unpacklo_pd(a, b).as_f64x8();
27639 transmute(simd_select_bitmask(k, unpacklo, f64x8::ZERO))
27640 }
27641}
27642
27643#[inline]
27647#[target_feature(enable = "avx512f,avx512vl")]
27648#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27649#[cfg_attr(test, assert_instr(vunpcklpd))]
27650#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27651pub const fn _mm256_mask_unpacklo_pd(src: __m256d, k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
27652 unsafe {
27653 let unpacklo = _mm256_unpacklo_pd(a, b).as_f64x4();
27654 transmute(simd_select_bitmask(k, unpacklo, src.as_f64x4()))
27655 }
27656}
27657
27658#[inline]
27662#[target_feature(enable = "avx512f,avx512vl")]
27663#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27664#[cfg_attr(test, assert_instr(vunpcklpd))]
27665#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27666pub const fn _mm256_maskz_unpacklo_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
27667 unsafe {
27668 let unpacklo = _mm256_unpacklo_pd(a, b).as_f64x4();
27669 transmute(simd_select_bitmask(k, unpacklo, f64x4::ZERO))
27670 }
27671}
27672
27673#[inline]
27677#[target_feature(enable = "avx512f,avx512vl")]
27678#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27679#[cfg_attr(test, assert_instr(vunpcklpd))]
27680#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27681pub const fn _mm_mask_unpacklo_pd(src: __m128d, k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
27682 unsafe {
27683 let unpacklo = _mm_unpacklo_pd(a, b).as_f64x2();
27684 transmute(simd_select_bitmask(k, unpacklo, src.as_f64x2()))
27685 }
27686}
27687
27688#[inline]
27692#[target_feature(enable = "avx512f,avx512vl")]
27693#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27694#[cfg_attr(test, assert_instr(vunpcklpd))]
27695#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27696pub const fn _mm_maskz_unpacklo_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
27697 unsafe {
27698 let unpacklo = _mm_unpacklo_pd(a, b).as_f64x2();
27699 transmute(simd_select_bitmask(k, unpacklo, f64x2::ZERO))
27700 }
27701}
27702
27703#[inline]
27713#[target_feature(enable = "avx512f")]
27714#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27715#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27716pub const fn _mm512_castps128_ps512(a: __m128) -> __m512 {
27717 unsafe {
27718 simd_shuffle!(
27719 a,
27720 _mm_undefined_ps(),
27721 [0, 1, 2, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
27722 )
27723 }
27724}
27725
27726#[inline]
27736#[target_feature(enable = "avx512f")]
27737#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27738#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27739pub const fn _mm512_castps256_ps512(a: __m256) -> __m512 {
27740 unsafe {
27741 simd_shuffle!(
27742 a,
27743 _mm256_undefined_ps(),
27744 [0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8],
27745 )
27746 }
27747}
27748
27749#[inline]
27753#[target_feature(enable = "avx512f")]
27754#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27755#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27756pub const fn _mm512_zextps128_ps512(a: __m128) -> __m512 {
27757 unsafe {
27758 simd_shuffle!(
27759 a,
27760 _mm_set1_ps(0.),
27761 [0, 1, 2, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
27762 )
27763 }
27764}
27765
27766#[inline]
27770#[target_feature(enable = "avx512f")]
27771#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27772#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27773pub const fn _mm512_zextps256_ps512(a: __m256) -> __m512 {
27774 unsafe {
27775 simd_shuffle!(
27776 a,
27777 _mm256_set1_ps(0.),
27778 [0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8],
27779 )
27780 }
27781}
27782
27783#[inline]
27787#[target_feature(enable = "avx512f")]
27788#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27789#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27790pub const fn _mm512_castps512_ps128(a: __m512) -> __m128 {
27791 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3]) }
27792}
27793
27794#[inline]
27798#[target_feature(enable = "avx512f")]
27799#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27800#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27801pub const fn _mm512_castps512_ps256(a: __m512) -> __m256 {
27802 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7]) }
27803}
27804
27805#[inline]
27809#[target_feature(enable = "avx512f")]
27810#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27811#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27812pub const fn _mm512_castps_pd(a: __m512) -> __m512d {
27813 unsafe { transmute(a) }
27814}
27815
27816#[inline]
27820#[target_feature(enable = "avx512f")]
27821#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27822#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27823pub const fn _mm512_castps_si512(a: __m512) -> __m512i {
27824 unsafe { transmute(a) }
27825}
27826
27827#[inline]
27837#[target_feature(enable = "avx512f")]
27838#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27839#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27840pub const fn _mm512_castpd128_pd512(a: __m128d) -> __m512d {
27841 unsafe { simd_shuffle!(a, _mm_undefined_pd(), [0, 1, 2, 2, 2, 2, 2, 2]) }
27842}
27843
27844#[inline]
27854#[target_feature(enable = "avx512f")]
27855#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27856#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27857pub const fn _mm512_castpd256_pd512(a: __m256d) -> __m512d {
27858 unsafe { simd_shuffle!(a, _mm256_undefined_pd(), [0, 1, 2, 3, 4, 4, 4, 4]) }
27859}
27860
27861#[inline]
27865#[target_feature(enable = "avx512f")]
27866#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27867#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27868pub const fn _mm512_zextpd128_pd512(a: __m128d) -> __m512d {
27869 unsafe { simd_shuffle!(a, _mm_set1_pd(0.), [0, 1, 2, 2, 2, 2, 2, 2]) }
27870}
27871
27872#[inline]
27876#[target_feature(enable = "avx512f")]
27877#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27878#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27879pub const fn _mm512_zextpd256_pd512(a: __m256d) -> __m512d {
27880 unsafe { simd_shuffle!(a, _mm256_set1_pd(0.), [0, 1, 2, 3, 4, 4, 4, 4]) }
27881}
27882
27883#[inline]
27887#[target_feature(enable = "avx512f")]
27888#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27889#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27890pub const fn _mm512_castpd512_pd128(a: __m512d) -> __m128d {
27891 unsafe { simd_shuffle!(a, a, [0, 1]) }
27892}
27893
27894#[inline]
27898#[target_feature(enable = "avx512f")]
27899#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27900#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27901pub const fn _mm512_castpd512_pd256(a: __m512d) -> __m256d {
27902 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3]) }
27903}
27904
27905#[inline]
27909#[target_feature(enable = "avx512f")]
27910#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27911#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27912pub const fn _mm512_castpd_ps(a: __m512d) -> __m512 {
27913 unsafe { transmute(a) }
27914}
27915
27916#[inline]
27920#[target_feature(enable = "avx512f")]
27921#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27922#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27923pub const fn _mm512_castpd_si512(a: __m512d) -> __m512i {
27924 unsafe { transmute(a) }
27925}
27926
27927#[inline]
27937#[target_feature(enable = "avx512f")]
27938#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27939#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27940pub const fn _mm512_castsi128_si512(a: __m128i) -> __m512i {
27941 unsafe { simd_shuffle!(a, _mm_undefined_si128(), [0, 1, 2, 2, 2, 2, 2, 2]) }
27942}
27943
27944#[inline]
27954#[target_feature(enable = "avx512f")]
27955#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27956#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27957pub const fn _mm512_castsi256_si512(a: __m256i) -> __m512i {
27958 unsafe { simd_shuffle!(a, _mm256_undefined_si256(), [0, 1, 2, 3, 4, 4, 4, 4]) }
27959}
27960
27961#[inline]
27965#[target_feature(enable = "avx512f")]
27966#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27967#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27968pub const fn _mm512_zextsi128_si512(a: __m128i) -> __m512i {
27969 unsafe { simd_shuffle!(a, _mm_setzero_si128(), [0, 1, 2, 2, 2, 2, 2, 2]) }
27970}
27971
27972#[inline]
27976#[target_feature(enable = "avx512f")]
27977#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27978#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27979pub const fn _mm512_zextsi256_si512(a: __m256i) -> __m512i {
27980 unsafe { simd_shuffle!(a, _mm256_setzero_si256(), [0, 1, 2, 3, 4, 4, 4, 4]) }
27981}
27982
27983#[inline]
27987#[target_feature(enable = "avx512f")]
27988#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
27989#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
27990pub const fn _mm512_castsi512_si128(a: __m512i) -> __m128i {
27991 unsafe { simd_shuffle!(a, a, [0, 1]) }
27992}
27993
27994#[inline]
27998#[target_feature(enable = "avx512f")]
27999#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28000#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28001pub const fn _mm512_castsi512_si256(a: __m512i) -> __m256i {
28002 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3]) }
28003}
28004
28005#[inline]
28009#[target_feature(enable = "avx512f")]
28010#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28011#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28012pub const fn _mm512_castsi512_ps(a: __m512i) -> __m512 {
28013 unsafe { transmute(a) }
28014}
28015
28016#[inline]
28020#[target_feature(enable = "avx512f")]
28021#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28022#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28023pub const fn _mm512_castsi512_pd(a: __m512i) -> __m512d {
28024 unsafe { transmute(a) }
28025}
28026
28027#[inline]
28031#[target_feature(enable = "avx512f")]
28032#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28033#[cfg_attr(test, assert_instr(vmovd))]
28034#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28035pub const fn _mm512_cvtsi512_si32(a: __m512i) -> i32 {
28036 unsafe { simd_extract!(a.as_i32x16(), 0) }
28037}
28038
28039#[inline]
28043#[target_feature(enable = "avx512f")]
28044#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28045#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28046pub const fn _mm512_cvtss_f32(a: __m512) -> f32 {
28047 unsafe { simd_extract!(a, 0) }
28048}
28049
28050#[inline]
28054#[target_feature(enable = "avx512f")]
28055#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28056#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28057pub const fn _mm512_cvtsd_f64(a: __m512d) -> f64 {
28058 unsafe { simd_extract!(a, 0) }
28059}
28060
28061#[inline]
28065#[target_feature(enable = "avx512f")]
28066#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28067#[cfg_attr(test, assert_instr(vbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28069pub const fn _mm512_broadcastd_epi32(a: __m128i) -> __m512i {
28070 unsafe {
28071 let a = _mm512_castsi128_si512(a).as_i32x16();
28072 let ret: i32x16 = simd_shuffle!(a, a, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
28073 transmute(ret)
28074 }
28075}
28076
28077#[inline]
28081#[target_feature(enable = "avx512f")]
28082#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28083#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28085pub const fn _mm512_mask_broadcastd_epi32(src: __m512i, k: __mmask16, a: __m128i) -> __m512i {
28086 unsafe {
28087 let broadcast = _mm512_broadcastd_epi32(a).as_i32x16();
28088 transmute(simd_select_bitmask(k, broadcast, src.as_i32x16()))
28089 }
28090}
28091
28092#[inline]
28096#[target_feature(enable = "avx512f")]
28097#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28098#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28100pub const fn _mm512_maskz_broadcastd_epi32(k: __mmask16, a: __m128i) -> __m512i {
28101 unsafe {
28102 let broadcast = _mm512_broadcastd_epi32(a).as_i32x16();
28103 transmute(simd_select_bitmask(k, broadcast, i32x16::ZERO))
28104 }
28105}
28106
28107#[inline]
28111#[target_feature(enable = "avx512f,avx512vl")]
28112#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28113#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28115pub const fn _mm256_mask_broadcastd_epi32(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
28116 unsafe {
28117 let broadcast = _mm256_broadcastd_epi32(a).as_i32x8();
28118 transmute(simd_select_bitmask(k, broadcast, src.as_i32x8()))
28119 }
28120}
28121
28122#[inline]
28126#[target_feature(enable = "avx512f,avx512vl")]
28127#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28128#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28130pub const fn _mm256_maskz_broadcastd_epi32(k: __mmask8, a: __m128i) -> __m256i {
28131 unsafe {
28132 let broadcast = _mm256_broadcastd_epi32(a).as_i32x8();
28133 transmute(simd_select_bitmask(k, broadcast, i32x8::ZERO))
28134 }
28135}
28136
28137#[inline]
28141#[target_feature(enable = "avx512f,avx512vl")]
28142#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28143#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28145pub const fn _mm_mask_broadcastd_epi32(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
28146 unsafe {
28147 let broadcast = _mm_broadcastd_epi32(a).as_i32x4();
28148 transmute(simd_select_bitmask(k, broadcast, src.as_i32x4()))
28149 }
28150}
28151
28152#[inline]
28156#[target_feature(enable = "avx512f,avx512vl")]
28157#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28158#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28160pub const fn _mm_maskz_broadcastd_epi32(k: __mmask8, a: __m128i) -> __m128i {
28161 unsafe {
28162 let broadcast = _mm_broadcastd_epi32(a).as_i32x4();
28163 transmute(simd_select_bitmask(k, broadcast, i32x4::ZERO))
28164 }
28165}
28166
28167#[inline]
28171#[target_feature(enable = "avx512f")]
28172#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28173#[cfg_attr(test, assert_instr(vbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28175pub const fn _mm512_broadcastq_epi64(a: __m128i) -> __m512i {
28176 unsafe { simd_shuffle!(a, a, [0, 0, 0, 0, 0, 0, 0, 0]) }
28177}
28178
28179#[inline]
28183#[target_feature(enable = "avx512f")]
28184#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28185#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28187pub const fn _mm512_mask_broadcastq_epi64(src: __m512i, k: __mmask8, a: __m128i) -> __m512i {
28188 unsafe {
28189 let broadcast = _mm512_broadcastq_epi64(a).as_i64x8();
28190 transmute(simd_select_bitmask(k, broadcast, src.as_i64x8()))
28191 }
28192}
28193
28194#[inline]
28198#[target_feature(enable = "avx512f")]
28199#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28200#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28202pub const fn _mm512_maskz_broadcastq_epi64(k: __mmask8, a: __m128i) -> __m512i {
28203 unsafe {
28204 let broadcast = _mm512_broadcastq_epi64(a).as_i64x8();
28205 transmute(simd_select_bitmask(k, broadcast, i64x8::ZERO))
28206 }
28207}
28208
28209#[inline]
28213#[target_feature(enable = "avx512f,avx512vl")]
28214#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28215#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28217pub const fn _mm256_mask_broadcastq_epi64(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
28218 unsafe {
28219 let broadcast = _mm256_broadcastq_epi64(a).as_i64x4();
28220 transmute(simd_select_bitmask(k, broadcast, src.as_i64x4()))
28221 }
28222}
28223
28224#[inline]
28228#[target_feature(enable = "avx512f,avx512vl")]
28229#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28230#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28232pub const fn _mm256_maskz_broadcastq_epi64(k: __mmask8, a: __m128i) -> __m256i {
28233 unsafe {
28234 let broadcast = _mm256_broadcastq_epi64(a).as_i64x4();
28235 transmute(simd_select_bitmask(k, broadcast, i64x4::ZERO))
28236 }
28237}
28238
28239#[inline]
28243#[target_feature(enable = "avx512f,avx512vl")]
28244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28245#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28247pub const fn _mm_mask_broadcastq_epi64(src: __m128i, k: __mmask8, a: __m128i) -> __m128i {
28248 unsafe {
28249 let broadcast = _mm_broadcastq_epi64(a).as_i64x2();
28250 transmute(simd_select_bitmask(k, broadcast, src.as_i64x2()))
28251 }
28252}
28253
28254#[inline]
28258#[target_feature(enable = "avx512f,avx512vl")]
28259#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28260#[cfg_attr(test, assert_instr(vpbroadcast))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28262pub const fn _mm_maskz_broadcastq_epi64(k: __mmask8, a: __m128i) -> __m128i {
28263 unsafe {
28264 let broadcast = _mm_broadcastq_epi64(a).as_i64x2();
28265 transmute(simd_select_bitmask(k, broadcast, i64x2::ZERO))
28266 }
28267}
28268
28269#[inline]
28273#[target_feature(enable = "avx512f")]
28274#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28275#[cfg_attr(test, assert_instr(vbroadcastss))]
28276#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28277pub const fn _mm512_broadcastss_ps(a: __m128) -> __m512 {
28278 unsafe { simd_shuffle!(a, a, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
28279}
28280
28281#[inline]
28285#[target_feature(enable = "avx512f")]
28286#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28287#[cfg_attr(test, assert_instr(vbroadcastss))]
28288#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28289pub const fn _mm512_mask_broadcastss_ps(src: __m512, k: __mmask16, a: __m128) -> __m512 {
28290 unsafe {
28291 let broadcast = _mm512_broadcastss_ps(a).as_f32x16();
28292 transmute(simd_select_bitmask(k, broadcast, src.as_f32x16()))
28293 }
28294}
28295
28296#[inline]
28300#[target_feature(enable = "avx512f")]
28301#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28302#[cfg_attr(test, assert_instr(vbroadcastss))]
28303#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28304pub const fn _mm512_maskz_broadcastss_ps(k: __mmask16, a: __m128) -> __m512 {
28305 unsafe {
28306 let broadcast = _mm512_broadcastss_ps(a).as_f32x16();
28307 transmute(simd_select_bitmask(k, broadcast, f32x16::ZERO))
28308 }
28309}
28310
28311#[inline]
28315#[target_feature(enable = "avx512f,avx512vl")]
28316#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28317#[cfg_attr(test, assert_instr(vbroadcastss))]
28318#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28319pub const fn _mm256_mask_broadcastss_ps(src: __m256, k: __mmask8, a: __m128) -> __m256 {
28320 unsafe {
28321 let broadcast = _mm256_broadcastss_ps(a).as_f32x8();
28322 transmute(simd_select_bitmask(k, broadcast, src.as_f32x8()))
28323 }
28324}
28325
28326#[inline]
28330#[target_feature(enable = "avx512f,avx512vl")]
28331#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28332#[cfg_attr(test, assert_instr(vbroadcastss))]
28333#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28334pub const fn _mm256_maskz_broadcastss_ps(k: __mmask8, a: __m128) -> __m256 {
28335 unsafe {
28336 let broadcast = _mm256_broadcastss_ps(a).as_f32x8();
28337 transmute(simd_select_bitmask(k, broadcast, f32x8::ZERO))
28338 }
28339}
28340
28341#[inline]
28345#[target_feature(enable = "avx512f,avx512vl")]
28346#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28347#[cfg_attr(test, assert_instr(vbroadcastss))]
28348#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28349pub const fn _mm_mask_broadcastss_ps(src: __m128, k: __mmask8, a: __m128) -> __m128 {
28350 unsafe {
28351 let broadcast = _mm_broadcastss_ps(a).as_f32x4();
28352 transmute(simd_select_bitmask(k, broadcast, src.as_f32x4()))
28353 }
28354}
28355
28356#[inline]
28360#[target_feature(enable = "avx512f,avx512vl")]
28361#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28362#[cfg_attr(test, assert_instr(vbroadcastss))]
28363#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28364pub const fn _mm_maskz_broadcastss_ps(k: __mmask8, a: __m128) -> __m128 {
28365 unsafe {
28366 let broadcast = _mm_broadcastss_ps(a).as_f32x4();
28367 transmute(simd_select_bitmask(k, broadcast, f32x4::ZERO))
28368 }
28369}
28370
28371#[inline]
28375#[target_feature(enable = "avx512f")]
28376#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28377#[cfg_attr(test, assert_instr(vbroadcastsd))]
28378#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28379pub const fn _mm512_broadcastsd_pd(a: __m128d) -> __m512d {
28380 unsafe { simd_shuffle!(a, a, [0, 0, 0, 0, 0, 0, 0, 0]) }
28381}
28382
28383#[inline]
28387#[target_feature(enable = "avx512f")]
28388#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28389#[cfg_attr(test, assert_instr(vbroadcastsd))]
28390#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28391pub const fn _mm512_mask_broadcastsd_pd(src: __m512d, k: __mmask8, a: __m128d) -> __m512d {
28392 unsafe {
28393 let broadcast = _mm512_broadcastsd_pd(a).as_f64x8();
28394 transmute(simd_select_bitmask(k, broadcast, src.as_f64x8()))
28395 }
28396}
28397
28398#[inline]
28402#[target_feature(enable = "avx512f")]
28403#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28404#[cfg_attr(test, assert_instr(vbroadcastsd))]
28405#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28406pub const fn _mm512_maskz_broadcastsd_pd(k: __mmask8, a: __m128d) -> __m512d {
28407 unsafe {
28408 let broadcast = _mm512_broadcastsd_pd(a).as_f64x8();
28409 transmute(simd_select_bitmask(k, broadcast, f64x8::ZERO))
28410 }
28411}
28412
28413#[inline]
28417#[target_feature(enable = "avx512f,avx512vl")]
28418#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28419#[cfg_attr(test, assert_instr(vbroadcastsd))]
28420#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28421pub const fn _mm256_mask_broadcastsd_pd(src: __m256d, k: __mmask8, a: __m128d) -> __m256d {
28422 unsafe {
28423 let broadcast = _mm256_broadcastsd_pd(a).as_f64x4();
28424 transmute(simd_select_bitmask(k, broadcast, src.as_f64x4()))
28425 }
28426}
28427
28428#[inline]
28432#[target_feature(enable = "avx512f,avx512vl")]
28433#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28434#[cfg_attr(test, assert_instr(vbroadcastsd))]
28435#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28436pub const fn _mm256_maskz_broadcastsd_pd(k: __mmask8, a: __m128d) -> __m256d {
28437 unsafe {
28438 let broadcast = _mm256_broadcastsd_pd(a).as_f64x4();
28439 transmute(simd_select_bitmask(k, broadcast, f64x4::ZERO))
28440 }
28441}
28442
28443#[inline]
28447#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28449#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28450pub const fn _mm512_broadcast_i32x4(a: __m128i) -> __m512i {
28451 unsafe {
28452 let a = a.as_i32x4();
28453 let ret: i32x16 = simd_shuffle!(a, a, [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]);
28454 transmute(ret)
28455 }
28456}
28457
28458#[inline]
28462#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28464#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28465pub const fn _mm512_mask_broadcast_i32x4(src: __m512i, k: __mmask16, a: __m128i) -> __m512i {
28466 unsafe {
28467 let broadcast = _mm512_broadcast_i32x4(a).as_i32x16();
28468 transmute(simd_select_bitmask(k, broadcast, src.as_i32x16()))
28469 }
28470}
28471
28472#[inline]
28476#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28478#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28479pub const fn _mm512_maskz_broadcast_i32x4(k: __mmask16, a: __m128i) -> __m512i {
28480 unsafe {
28481 let broadcast = _mm512_broadcast_i32x4(a).as_i32x16();
28482 transmute(simd_select_bitmask(k, broadcast, i32x16::ZERO))
28483 }
28484}
28485
28486#[inline]
28490#[target_feature(enable = "avx512f,avx512vl")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28492#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28493pub const fn _mm256_broadcast_i32x4(a: __m128i) -> __m256i {
28494 unsafe {
28495 let a = a.as_i32x4();
28496 let ret: i32x8 = simd_shuffle!(a, a, [0, 1, 2, 3, 0, 1, 2, 3]);
28497 transmute(ret)
28498 }
28499}
28500
28501#[inline]
28505#[target_feature(enable = "avx512f,avx512vl")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28507#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28508pub const fn _mm256_mask_broadcast_i32x4(src: __m256i, k: __mmask8, a: __m128i) -> __m256i {
28509 unsafe {
28510 let broadcast = _mm256_broadcast_i32x4(a).as_i32x8();
28511 transmute(simd_select_bitmask(k, broadcast, src.as_i32x8()))
28512 }
28513}
28514
28515#[inline]
28519#[target_feature(enable = "avx512f,avx512vl")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28521#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28522pub const fn _mm256_maskz_broadcast_i32x4(k: __mmask8, a: __m128i) -> __m256i {
28523 unsafe {
28524 let broadcast = _mm256_broadcast_i32x4(a).as_i32x8();
28525 transmute(simd_select_bitmask(k, broadcast, i32x8::ZERO))
28526 }
28527}
28528
28529#[inline]
28533#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28535#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28536pub const fn _mm512_broadcast_i64x4(a: __m256i) -> __m512i {
28537 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 0, 1, 2, 3]) }
28538}
28539
28540#[inline]
28544#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28546#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28547pub const fn _mm512_mask_broadcast_i64x4(src: __m512i, k: __mmask8, a: __m256i) -> __m512i {
28548 unsafe {
28549 let broadcast = _mm512_broadcast_i64x4(a).as_i64x8();
28550 transmute(simd_select_bitmask(k, broadcast, src.as_i64x8()))
28551 }
28552}
28553
28554#[inline]
28558#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28560#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28561pub const fn _mm512_maskz_broadcast_i64x4(k: __mmask8, a: __m256i) -> __m512i {
28562 unsafe {
28563 let broadcast = _mm512_broadcast_i64x4(a).as_i64x8();
28564 transmute(simd_select_bitmask(k, broadcast, i64x8::ZERO))
28565 }
28566}
28567
28568#[inline]
28572#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28574#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28575pub const fn _mm512_broadcast_f32x4(a: __m128) -> __m512 {
28576 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]) }
28577}
28578
28579#[inline]
28583#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28585#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28586pub const fn _mm512_mask_broadcast_f32x4(src: __m512, k: __mmask16, a: __m128) -> __m512 {
28587 unsafe {
28588 let broadcast = _mm512_broadcast_f32x4(a).as_f32x16();
28589 transmute(simd_select_bitmask(k, broadcast, src.as_f32x16()))
28590 }
28591}
28592
28593#[inline]
28597#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28599#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28600pub const fn _mm512_maskz_broadcast_f32x4(k: __mmask16, a: __m128) -> __m512 {
28601 unsafe {
28602 let broadcast = _mm512_broadcast_f32x4(a).as_f32x16();
28603 transmute(simd_select_bitmask(k, broadcast, f32x16::ZERO))
28604 }
28605}
28606
28607#[inline]
28611#[target_feature(enable = "avx512f,avx512vl")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28613#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28614pub const fn _mm256_broadcast_f32x4(a: __m128) -> __m256 {
28615 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 0, 1, 2, 3]) }
28616}
28617
28618#[inline]
28622#[target_feature(enable = "avx512f,avx512vl")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28624#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28625pub const fn _mm256_mask_broadcast_f32x4(src: __m256, k: __mmask8, a: __m128) -> __m256 {
28626 unsafe {
28627 let broadcast = _mm256_broadcast_f32x4(a).as_f32x8();
28628 transmute(simd_select_bitmask(k, broadcast, src.as_f32x8()))
28629 }
28630}
28631
28632#[inline]
28636#[target_feature(enable = "avx512f,avx512vl")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28638#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28639pub const fn _mm256_maskz_broadcast_f32x4(k: __mmask8, a: __m128) -> __m256 {
28640 unsafe {
28641 let broadcast = _mm256_broadcast_f32x4(a).as_f32x8();
28642 transmute(simd_select_bitmask(k, broadcast, f32x8::ZERO))
28643 }
28644}
28645
28646#[inline]
28650#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28652#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28653pub const fn _mm512_broadcast_f64x4(a: __m256d) -> __m512d {
28654 unsafe { simd_shuffle!(a, a, [0, 1, 2, 3, 0, 1, 2, 3]) }
28655}
28656
28657#[inline]
28661#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28663#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28664pub const fn _mm512_mask_broadcast_f64x4(src: __m512d, k: __mmask8, a: __m256d) -> __m512d {
28665 unsafe {
28666 let broadcast = _mm512_broadcast_f64x4(a).as_f64x8();
28667 transmute(simd_select_bitmask(k, broadcast, src.as_f64x8()))
28668 }
28669}
28670
28671#[inline]
28675#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28677#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28678pub const fn _mm512_maskz_broadcast_f64x4(k: __mmask8, a: __m256d) -> __m512d {
28679 unsafe {
28680 let broadcast = _mm512_broadcast_f64x4(a).as_f64x8();
28681 transmute(simd_select_bitmask(k, broadcast, f64x8::ZERO))
28682 }
28683}
28684
28685#[inline]
28689#[target_feature(enable = "avx512f")]
28690#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28691#[cfg_attr(test, assert_instr(vmovdqa32))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28693pub const fn _mm512_mask_blend_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
28694 unsafe { transmute(simd_select_bitmask(k, b.as_i32x16(), a.as_i32x16())) }
28695}
28696
28697#[inline]
28701#[target_feature(enable = "avx512f,avx512vl")]
28702#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28703#[cfg_attr(test, assert_instr(vmovdqa32))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28705pub const fn _mm256_mask_blend_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
28706 unsafe { transmute(simd_select_bitmask(k, b.as_i32x8(), a.as_i32x8())) }
28707}
28708
28709#[inline]
28713#[target_feature(enable = "avx512f,avx512vl")]
28714#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28715#[cfg_attr(test, assert_instr(vmovdqa32))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28717pub const fn _mm_mask_blend_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
28718 unsafe { transmute(simd_select_bitmask(k, b.as_i32x4(), a.as_i32x4())) }
28719}
28720
28721#[inline]
28725#[target_feature(enable = "avx512f")]
28726#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28727#[cfg_attr(test, assert_instr(vmovdqa64))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28729pub const fn _mm512_mask_blend_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
28730 unsafe { transmute(simd_select_bitmask(k, b.as_i64x8(), a.as_i64x8())) }
28731}
28732
28733#[inline]
28737#[target_feature(enable = "avx512f,avx512vl")]
28738#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28739#[cfg_attr(test, assert_instr(vmovdqa64))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28741pub const fn _mm256_mask_blend_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
28742 unsafe { transmute(simd_select_bitmask(k, b.as_i64x4(), a.as_i64x4())) }
28743}
28744
28745#[inline]
28749#[target_feature(enable = "avx512f,avx512vl")]
28750#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28751#[cfg_attr(test, assert_instr(vmovdqa64))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28753pub const fn _mm_mask_blend_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
28754 unsafe { transmute(simd_select_bitmask(k, b.as_i64x2(), a.as_i64x2())) }
28755}
28756
28757#[inline]
28761#[target_feature(enable = "avx512f")]
28762#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28763#[cfg_attr(test, assert_instr(vmovaps))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28765pub const fn _mm512_mask_blend_ps(k: __mmask16, a: __m512, b: __m512) -> __m512 {
28766 unsafe { transmute(simd_select_bitmask(k, b.as_f32x16(), a.as_f32x16())) }
28767}
28768
28769#[inline]
28773#[target_feature(enable = "avx512f,avx512vl")]
28774#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28775#[cfg_attr(test, assert_instr(vmovaps))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28777pub const fn _mm256_mask_blend_ps(k: __mmask8, a: __m256, b: __m256) -> __m256 {
28778 unsafe { transmute(simd_select_bitmask(k, b.as_f32x8(), a.as_f32x8())) }
28779}
28780
28781#[inline]
28785#[target_feature(enable = "avx512f,avx512vl")]
28786#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28787#[cfg_attr(test, assert_instr(vmovaps))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28789pub const fn _mm_mask_blend_ps(k: __mmask8, a: __m128, b: __m128) -> __m128 {
28790 unsafe { transmute(simd_select_bitmask(k, b.as_f32x4(), a.as_f32x4())) }
28791}
28792
28793#[inline]
28797#[target_feature(enable = "avx512f")]
28798#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28799#[cfg_attr(test, assert_instr(vmovapd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28801pub const fn _mm512_mask_blend_pd(k: __mmask8, a: __m512d, b: __m512d) -> __m512d {
28802 unsafe { transmute(simd_select_bitmask(k, b.as_f64x8(), a.as_f64x8())) }
28803}
28804
28805#[inline]
28809#[target_feature(enable = "avx512f,avx512vl")]
28810#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28811#[cfg_attr(test, assert_instr(vmovapd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28813pub const fn _mm256_mask_blend_pd(k: __mmask8, a: __m256d, b: __m256d) -> __m256d {
28814 unsafe { transmute(simd_select_bitmask(k, b.as_f64x4(), a.as_f64x4())) }
28815}
28816
28817#[inline]
28821#[target_feature(enable = "avx512f,avx512vl")]
28822#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28823#[cfg_attr(test, assert_instr(vmovapd))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28825pub const fn _mm_mask_blend_pd(k: __mmask8, a: __m128d, b: __m128d) -> __m128d {
28826 unsafe { transmute(simd_select_bitmask(k, b.as_f64x2(), a.as_f64x2())) }
28827}
28828
28829#[inline]
28835#[target_feature(enable = "avx512f")]
28836#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28837#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
28838#[rustc_legacy_const_generics(2)]
28839#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28840pub const fn _mm512_alignr_epi32<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
28841 unsafe {
28842 static_assert_uimm_bits!(IMM8, 8);
28843 let a = a.as_i32x16();
28844 let b = b.as_i32x16();
28845 let imm8: i32 = IMM8 % 16;
28846 let r: i32x16 = match imm8 {
28847 0 => simd_shuffle!(
28848 a,
28849 b,
28850 [
28851 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
28852 ],
28853 ),
28854 1 => simd_shuffle!(
28855 a,
28856 b,
28857 [
28858 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0,
28859 ],
28860 ),
28861 2 => simd_shuffle!(
28862 a,
28863 b,
28864 [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1],
28865 ),
28866 3 => simd_shuffle!(
28867 a,
28868 b,
28869 [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2],
28870 ),
28871 4 => simd_shuffle!(
28872 a,
28873 b,
28874 [20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3],
28875 ),
28876 5 => simd_shuffle!(
28877 a,
28878 b,
28879 [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4],
28880 ),
28881 6 => simd_shuffle!(
28882 a,
28883 b,
28884 [22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5],
28885 ),
28886 7 => simd_shuffle!(
28887 a,
28888 b,
28889 [23, 24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6],
28890 ),
28891 8 => simd_shuffle!(
28892 a,
28893 b,
28894 [24, 25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7],
28895 ),
28896 9 => simd_shuffle!(
28897 a,
28898 b,
28899 [25, 26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8],
28900 ),
28901 10 => simd_shuffle!(a, b, [26, 27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
28902 11 => simd_shuffle!(a, b, [27, 28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
28903 12 => simd_shuffle!(a, b, [28, 29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]),
28904 13 => simd_shuffle!(a, b, [29, 30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
28905 14 => simd_shuffle!(a, b, [30, 31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]),
28906 15 => simd_shuffle!(a, b, [31, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]),
28907 _ => unreachable_unchecked(),
28908 };
28909 transmute(r)
28910 }
28911}
28912
28913#[inline]
28917#[target_feature(enable = "avx512f")]
28918#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28919#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
28920#[rustc_legacy_const_generics(4)]
28921#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28922pub const fn _mm512_mask_alignr_epi32<const IMM8: i32>(
28923 src: __m512i,
28924 k: __mmask16,
28925 a: __m512i,
28926 b: __m512i,
28927) -> __m512i {
28928 unsafe {
28929 static_assert_uimm_bits!(IMM8, 8);
28930 let r = _mm512_alignr_epi32::<IMM8>(a, b);
28931 transmute(simd_select_bitmask(k, r.as_i32x16(), src.as_i32x16()))
28932 }
28933}
28934
28935#[inline]
28939#[target_feature(enable = "avx512f")]
28940#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28941#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
28942#[rustc_legacy_const_generics(3)]
28943#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28944pub const fn _mm512_maskz_alignr_epi32<const IMM8: i32>(
28945 k: __mmask16,
28946 a: __m512i,
28947 b: __m512i,
28948) -> __m512i {
28949 unsafe {
28950 static_assert_uimm_bits!(IMM8, 8);
28951 let r = _mm512_alignr_epi32::<IMM8>(a, b);
28952 transmute(simd_select_bitmask(k, r.as_i32x16(), i32x16::ZERO))
28953 }
28954}
28955
28956#[inline]
28962#[target_feature(enable = "avx512f,avx512vl")]
28963#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28964#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
28965#[rustc_legacy_const_generics(2)]
28966#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28967pub const fn _mm256_alignr_epi32<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
28968 unsafe {
28969 static_assert_uimm_bits!(IMM8, 8);
28970 let a = a.as_i32x8();
28971 let b = b.as_i32x8();
28972 let imm8: i32 = IMM8 % 8;
28973 let r: i32x8 = match imm8 {
28974 0 => simd_shuffle!(a, b, [8, 9, 10, 11, 12, 13, 14, 15]),
28975 1 => simd_shuffle!(a, b, [9, 10, 11, 12, 13, 14, 15, 0]),
28976 2 => simd_shuffle!(a, b, [10, 11, 12, 13, 14, 15, 0, 1]),
28977 3 => simd_shuffle!(a, b, [11, 12, 13, 14, 15, 0, 1, 2]),
28978 4 => simd_shuffle!(a, b, [12, 13, 14, 15, 0, 1, 2, 3]),
28979 5 => simd_shuffle!(a, b, [13, 14, 15, 0, 1, 2, 3, 4]),
28980 6 => simd_shuffle!(a, b, [14, 15, 0, 1, 2, 3, 4, 5]),
28981 7 => simd_shuffle!(a, b, [15, 0, 1, 2, 3, 4, 5, 6]),
28982 _ => unreachable_unchecked(),
28983 };
28984 transmute(r)
28985 }
28986}
28987
28988#[inline]
28992#[target_feature(enable = "avx512f,avx512vl")]
28993#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
28994#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
28995#[rustc_legacy_const_generics(4)]
28996#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
28997pub const fn _mm256_mask_alignr_epi32<const IMM8: i32>(
28998 src: __m256i,
28999 k: __mmask8,
29000 a: __m256i,
29001 b: __m256i,
29002) -> __m256i {
29003 unsafe {
29004 static_assert_uimm_bits!(IMM8, 8);
29005 let r = _mm256_alignr_epi32::<IMM8>(a, b);
29006 transmute(simd_select_bitmask(k, r.as_i32x8(), src.as_i32x8()))
29007 }
29008}
29009
29010#[inline]
29014#[target_feature(enable = "avx512f,avx512vl")]
29015#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29016#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
29017#[rustc_legacy_const_generics(3)]
29018#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29019pub const fn _mm256_maskz_alignr_epi32<const IMM8: i32>(
29020 k: __mmask8,
29021 a: __m256i,
29022 b: __m256i,
29023) -> __m256i {
29024 unsafe {
29025 static_assert_uimm_bits!(IMM8, 8);
29026 let r = _mm256_alignr_epi32::<IMM8>(a, b);
29027 transmute(simd_select_bitmask(k, r.as_i32x8(), i32x8::ZERO))
29028 }
29029}
29030
29031#[inline]
29037#[target_feature(enable = "avx512f,avx512vl")]
29038#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29039#[cfg_attr(test, assert_instr(vpalignr, IMM8 = 1))] #[rustc_legacy_const_generics(2)]
29041#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29042pub const fn _mm_alignr_epi32<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
29043 unsafe {
29044 static_assert_uimm_bits!(IMM8, 8);
29045 let a = a.as_i32x4();
29046 let b = b.as_i32x4();
29047 let imm8: i32 = IMM8 % 4;
29048 let r: i32x4 = match imm8 {
29049 0 => simd_shuffle!(a, b, [4, 5, 6, 7]),
29050 1 => simd_shuffle!(a, b, [5, 6, 7, 0]),
29051 2 => simd_shuffle!(a, b, [6, 7, 0, 1]),
29052 3 => simd_shuffle!(a, b, [7, 0, 1, 2]),
29053 _ => unreachable_unchecked(),
29054 };
29055 transmute(r)
29056 }
29057}
29058
29059#[inline]
29063#[target_feature(enable = "avx512f,avx512vl")]
29064#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29065#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
29066#[rustc_legacy_const_generics(4)]
29067#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29068pub const fn _mm_mask_alignr_epi32<const IMM8: i32>(
29069 src: __m128i,
29070 k: __mmask8,
29071 a: __m128i,
29072 b: __m128i,
29073) -> __m128i {
29074 unsafe {
29075 static_assert_uimm_bits!(IMM8, 8);
29076 let r = _mm_alignr_epi32::<IMM8>(a, b);
29077 transmute(simd_select_bitmask(k, r.as_i32x4(), src.as_i32x4()))
29078 }
29079}
29080
29081#[inline]
29085#[target_feature(enable = "avx512f,avx512vl")]
29086#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29087#[cfg_attr(test, assert_instr(valignd, IMM8 = 1))]
29088#[rustc_legacy_const_generics(3)]
29089#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29090pub const fn _mm_maskz_alignr_epi32<const IMM8: i32>(
29091 k: __mmask8,
29092 a: __m128i,
29093 b: __m128i,
29094) -> __m128i {
29095 unsafe {
29096 static_assert_uimm_bits!(IMM8, 8);
29097 let r = _mm_alignr_epi32::<IMM8>(a, b);
29098 transmute(simd_select_bitmask(k, r.as_i32x4(), i32x4::ZERO))
29099 }
29100}
29101
29102#[inline]
29108#[target_feature(enable = "avx512f")]
29109#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29110#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29111#[rustc_legacy_const_generics(2)]
29112#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29113pub const fn _mm512_alignr_epi64<const IMM8: i32>(a: __m512i, b: __m512i) -> __m512i {
29114 unsafe {
29115 static_assert_uimm_bits!(IMM8, 8);
29116 let imm8: i32 = IMM8 % 8;
29117 let r: i64x8 = match imm8 {
29118 0 => simd_shuffle!(a, b, [8, 9, 10, 11, 12, 13, 14, 15]),
29119 1 => simd_shuffle!(a, b, [9, 10, 11, 12, 13, 14, 15, 0]),
29120 2 => simd_shuffle!(a, b, [10, 11, 12, 13, 14, 15, 0, 1]),
29121 3 => simd_shuffle!(a, b, [11, 12, 13, 14, 15, 0, 1, 2]),
29122 4 => simd_shuffle!(a, b, [12, 13, 14, 15, 0, 1, 2, 3]),
29123 5 => simd_shuffle!(a, b, [13, 14, 15, 0, 1, 2, 3, 4]),
29124 6 => simd_shuffle!(a, b, [14, 15, 0, 1, 2, 3, 4, 5]),
29125 7 => simd_shuffle!(a, b, [15, 0, 1, 2, 3, 4, 5, 6]),
29126 _ => unreachable_unchecked(),
29127 };
29128 transmute(r)
29129 }
29130}
29131
29132#[inline]
29136#[target_feature(enable = "avx512f")]
29137#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29138#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29139#[rustc_legacy_const_generics(4)]
29140#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29141pub const fn _mm512_mask_alignr_epi64<const IMM8: i32>(
29142 src: __m512i,
29143 k: __mmask8,
29144 a: __m512i,
29145 b: __m512i,
29146) -> __m512i {
29147 unsafe {
29148 static_assert_uimm_bits!(IMM8, 8);
29149 let r = _mm512_alignr_epi64::<IMM8>(a, b);
29150 transmute(simd_select_bitmask(k, r.as_i64x8(), src.as_i64x8()))
29151 }
29152}
29153
29154#[inline]
29158#[target_feature(enable = "avx512f")]
29159#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29160#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29161#[rustc_legacy_const_generics(3)]
29162#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29163pub const fn _mm512_maskz_alignr_epi64<const IMM8: i32>(
29164 k: __mmask8,
29165 a: __m512i,
29166 b: __m512i,
29167) -> __m512i {
29168 unsafe {
29169 static_assert_uimm_bits!(IMM8, 8);
29170 let r = _mm512_alignr_epi64::<IMM8>(a, b);
29171 transmute(simd_select_bitmask(k, r.as_i64x8(), i64x8::ZERO))
29172 }
29173}
29174
29175#[inline]
29181#[target_feature(enable = "avx512f,avx512vl")]
29182#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29183#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29184#[rustc_legacy_const_generics(2)]
29185#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29186pub const fn _mm256_alignr_epi64<const IMM8: i32>(a: __m256i, b: __m256i) -> __m256i {
29187 unsafe {
29188 static_assert_uimm_bits!(IMM8, 8);
29189 let imm8: i32 = IMM8 % 4;
29190 let r: i64x4 = match imm8 {
29191 0 => simd_shuffle!(a, b, [4, 5, 6, 7]),
29192 1 => simd_shuffle!(a, b, [5, 6, 7, 0]),
29193 2 => simd_shuffle!(a, b, [6, 7, 0, 1]),
29194 3 => simd_shuffle!(a, b, [7, 0, 1, 2]),
29195 _ => unreachable_unchecked(),
29196 };
29197 transmute(r)
29198 }
29199}
29200
29201#[inline]
29205#[target_feature(enable = "avx512f,avx512vl")]
29206#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29207#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29208#[rustc_legacy_const_generics(4)]
29209#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29210pub const fn _mm256_mask_alignr_epi64<const IMM8: i32>(
29211 src: __m256i,
29212 k: __mmask8,
29213 a: __m256i,
29214 b: __m256i,
29215) -> __m256i {
29216 unsafe {
29217 static_assert_uimm_bits!(IMM8, 8);
29218 let r = _mm256_alignr_epi64::<IMM8>(a, b);
29219 transmute(simd_select_bitmask(k, r.as_i64x4(), src.as_i64x4()))
29220 }
29221}
29222
29223#[inline]
29227#[target_feature(enable = "avx512f,avx512vl")]
29228#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29229#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29230#[rustc_legacy_const_generics(3)]
29231#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29232pub const fn _mm256_maskz_alignr_epi64<const IMM8: i32>(
29233 k: __mmask8,
29234 a: __m256i,
29235 b: __m256i,
29236) -> __m256i {
29237 unsafe {
29238 static_assert_uimm_bits!(IMM8, 8);
29239 let r = _mm256_alignr_epi64::<IMM8>(a, b);
29240 transmute(simd_select_bitmask(k, r.as_i64x4(), i64x4::ZERO))
29241 }
29242}
29243
29244#[inline]
29250#[target_feature(enable = "avx512f,avx512vl")]
29251#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29252#[cfg_attr(test, assert_instr(vpalignr, IMM8 = 1))] #[rustc_legacy_const_generics(2)]
29254#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29255pub const fn _mm_alignr_epi64<const IMM8: i32>(a: __m128i, b: __m128i) -> __m128i {
29256 unsafe {
29257 static_assert_uimm_bits!(IMM8, 8);
29258 let imm8: i32 = IMM8 % 2;
29259 let r: i64x2 = match imm8 {
29260 0 => simd_shuffle!(a, b, [2, 3]),
29261 1 => simd_shuffle!(a, b, [3, 0]),
29262 _ => unreachable_unchecked(),
29263 };
29264 transmute(r)
29265 }
29266}
29267
29268#[inline]
29272#[target_feature(enable = "avx512f,avx512vl")]
29273#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29274#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29275#[rustc_legacy_const_generics(4)]
29276#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29277pub const fn _mm_mask_alignr_epi64<const IMM8: i32>(
29278 src: __m128i,
29279 k: __mmask8,
29280 a: __m128i,
29281 b: __m128i,
29282) -> __m128i {
29283 unsafe {
29284 static_assert_uimm_bits!(IMM8, 8);
29285 let r = _mm_alignr_epi64::<IMM8>(a, b);
29286 transmute(simd_select_bitmask(k, r.as_i64x2(), src.as_i64x2()))
29287 }
29288}
29289
29290#[inline]
29294#[target_feature(enable = "avx512f,avx512vl")]
29295#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29296#[cfg_attr(test, assert_instr(valignq, IMM8 = 1))]
29297#[rustc_legacy_const_generics(3)]
29298#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29299pub const fn _mm_maskz_alignr_epi64<const IMM8: i32>(
29300 k: __mmask8,
29301 a: __m128i,
29302 b: __m128i,
29303) -> __m128i {
29304 unsafe {
29305 static_assert_uimm_bits!(IMM8, 8);
29306 let r = _mm_alignr_epi64::<IMM8>(a, b);
29307 transmute(simd_select_bitmask(k, r.as_i64x2(), i64x2::ZERO))
29308 }
29309}
29310
29311#[inline]
29315#[target_feature(enable = "avx512f")]
29316#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29317#[cfg_attr(test, assert_instr(vpandq))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29319pub const fn _mm512_and_epi32(a: __m512i, b: __m512i) -> __m512i {
29320 unsafe { transmute(simd_and(a.as_i32x16(), b.as_i32x16())) }
29321}
29322
29323#[inline]
29327#[target_feature(enable = "avx512f")]
29328#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29329#[cfg_attr(test, assert_instr(vpandd))]
29330#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29331pub const fn _mm512_mask_and_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
29332 unsafe {
29333 let and = _mm512_and_epi32(a, b).as_i32x16();
29334 transmute(simd_select_bitmask(k, and, src.as_i32x16()))
29335 }
29336}
29337
29338#[inline]
29342#[target_feature(enable = "avx512f")]
29343#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29344#[cfg_attr(test, assert_instr(vpandd))]
29345#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29346pub const fn _mm512_maskz_and_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
29347 unsafe {
29348 let and = _mm512_and_epi32(a, b).as_i32x16();
29349 transmute(simd_select_bitmask(k, and, i32x16::ZERO))
29350 }
29351}
29352
29353#[inline]
29357#[target_feature(enable = "avx512f,avx512vl")]
29358#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29359#[cfg_attr(test, assert_instr(vpandd))]
29360#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29361pub const fn _mm256_mask_and_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29362 unsafe {
29363 let and = simd_and(a.as_i32x8(), b.as_i32x8());
29364 transmute(simd_select_bitmask(k, and, src.as_i32x8()))
29365 }
29366}
29367
29368#[inline]
29372#[target_feature(enable = "avx512f,avx512vl")]
29373#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29374#[cfg_attr(test, assert_instr(vpandd))]
29375#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29376pub const fn _mm256_maskz_and_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29377 unsafe {
29378 let and = simd_and(a.as_i32x8(), b.as_i32x8());
29379 transmute(simd_select_bitmask(k, and, i32x8::ZERO))
29380 }
29381}
29382
29383#[inline]
29387#[target_feature(enable = "avx512f,avx512vl")]
29388#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29389#[cfg_attr(test, assert_instr(vpandd))]
29390#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29391pub const fn _mm_mask_and_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29392 unsafe {
29393 let and = simd_and(a.as_i32x4(), b.as_i32x4());
29394 transmute(simd_select_bitmask(k, and, src.as_i32x4()))
29395 }
29396}
29397
29398#[inline]
29402#[target_feature(enable = "avx512f,avx512vl")]
29403#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29404#[cfg_attr(test, assert_instr(vpandd))]
29405#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29406pub const fn _mm_maskz_and_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29407 unsafe {
29408 let and = simd_and(a.as_i32x4(), b.as_i32x4());
29409 transmute(simd_select_bitmask(k, and, i32x4::ZERO))
29410 }
29411}
29412
29413#[inline]
29417#[target_feature(enable = "avx512f")]
29418#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29419#[cfg_attr(test, assert_instr(vpandq))]
29420#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29421pub const fn _mm512_and_epi64(a: __m512i, b: __m512i) -> __m512i {
29422 unsafe { transmute(simd_and(a.as_i64x8(), b.as_i64x8())) }
29423}
29424
29425#[inline]
29429#[target_feature(enable = "avx512f")]
29430#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29431#[cfg_attr(test, assert_instr(vpandq))]
29432#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29433pub const fn _mm512_mask_and_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
29434 unsafe {
29435 let and = _mm512_and_epi64(a, b).as_i64x8();
29436 transmute(simd_select_bitmask(k, and, src.as_i64x8()))
29437 }
29438}
29439
29440#[inline]
29444#[target_feature(enable = "avx512f")]
29445#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29446#[cfg_attr(test, assert_instr(vpandq))]
29447#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29448pub const fn _mm512_maskz_and_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
29449 unsafe {
29450 let and = _mm512_and_epi64(a, b).as_i64x8();
29451 transmute(simd_select_bitmask(k, and, i64x8::ZERO))
29452 }
29453}
29454
29455#[inline]
29459#[target_feature(enable = "avx512f,avx512vl")]
29460#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29461#[cfg_attr(test, assert_instr(vpandq))]
29462#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29463pub const fn _mm256_mask_and_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29464 unsafe {
29465 let and = simd_and(a.as_i64x4(), b.as_i64x4());
29466 transmute(simd_select_bitmask(k, and, src.as_i64x4()))
29467 }
29468}
29469
29470#[inline]
29474#[target_feature(enable = "avx512f,avx512vl")]
29475#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29476#[cfg_attr(test, assert_instr(vpandq))]
29477#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29478pub const fn _mm256_maskz_and_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29479 unsafe {
29480 let and = simd_and(a.as_i64x4(), b.as_i64x4());
29481 transmute(simd_select_bitmask(k, and, i64x4::ZERO))
29482 }
29483}
29484
29485#[inline]
29489#[target_feature(enable = "avx512f,avx512vl")]
29490#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29491#[cfg_attr(test, assert_instr(vpandq))]
29492#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29493pub const fn _mm_mask_and_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29494 unsafe {
29495 let and = simd_and(a.as_i64x2(), b.as_i64x2());
29496 transmute(simd_select_bitmask(k, and, src.as_i64x2()))
29497 }
29498}
29499
29500#[inline]
29504#[target_feature(enable = "avx512f,avx512vl")]
29505#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29506#[cfg_attr(test, assert_instr(vpandq))]
29507#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29508pub const fn _mm_maskz_and_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29509 unsafe {
29510 let and = simd_and(a.as_i64x2(), b.as_i64x2());
29511 transmute(simd_select_bitmask(k, and, i64x2::ZERO))
29512 }
29513}
29514
29515#[inline]
29519#[target_feature(enable = "avx512f")]
29520#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29521#[cfg_attr(test, assert_instr(vpandq))]
29522#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29523pub const fn _mm512_and_si512(a: __m512i, b: __m512i) -> __m512i {
29524 unsafe { transmute(simd_and(a.as_i32x16(), b.as_i32x16())) }
29525}
29526
29527#[inline]
29531#[target_feature(enable = "avx512f")]
29532#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29533#[cfg_attr(test, assert_instr(vporq))]
29534#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29535pub const fn _mm512_or_epi32(a: __m512i, b: __m512i) -> __m512i {
29536 unsafe { transmute(simd_or(a.as_i32x16(), b.as_i32x16())) }
29537}
29538
29539#[inline]
29543#[target_feature(enable = "avx512f")]
29544#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29545#[cfg_attr(test, assert_instr(vpord))]
29546#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29547pub const fn _mm512_mask_or_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
29548 unsafe {
29549 let or = _mm512_or_epi32(a, b).as_i32x16();
29550 transmute(simd_select_bitmask(k, or, src.as_i32x16()))
29551 }
29552}
29553
29554#[inline]
29558#[target_feature(enable = "avx512f")]
29559#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29560#[cfg_attr(test, assert_instr(vpord))]
29561#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29562pub const fn _mm512_maskz_or_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
29563 unsafe {
29564 let or = _mm512_or_epi32(a, b).as_i32x16();
29565 transmute(simd_select_bitmask(k, or, i32x16::ZERO))
29566 }
29567}
29568
29569#[inline]
29573#[target_feature(enable = "avx512f,avx512vl")]
29574#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29575#[cfg_attr(test, assert_instr(vor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29577pub const fn _mm256_or_epi32(a: __m256i, b: __m256i) -> __m256i {
29578 unsafe { transmute(simd_or(a.as_i32x8(), b.as_i32x8())) }
29579}
29580
29581#[inline]
29585#[target_feature(enable = "avx512f,avx512vl")]
29586#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29587#[cfg_attr(test, assert_instr(vpord))]
29588#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29589pub const fn _mm256_mask_or_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29590 unsafe {
29591 let or = _mm256_or_epi32(a, b).as_i32x8();
29592 transmute(simd_select_bitmask(k, or, src.as_i32x8()))
29593 }
29594}
29595
29596#[inline]
29600#[target_feature(enable = "avx512f,avx512vl")]
29601#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29602#[cfg_attr(test, assert_instr(vpord))]
29603#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29604pub const fn _mm256_maskz_or_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29605 unsafe {
29606 let or = _mm256_or_epi32(a, b).as_i32x8();
29607 transmute(simd_select_bitmask(k, or, i32x8::ZERO))
29608 }
29609}
29610
29611#[inline]
29615#[target_feature(enable = "avx512f,avx512vl")]
29616#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29617#[cfg_attr(test, assert_instr(vor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29619pub const fn _mm_or_epi32(a: __m128i, b: __m128i) -> __m128i {
29620 unsafe { transmute(simd_or(a.as_i32x4(), b.as_i32x4())) }
29621}
29622
29623#[inline]
29627#[target_feature(enable = "avx512f,avx512vl")]
29628#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29629#[cfg_attr(test, assert_instr(vpord))]
29630#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29631pub const fn _mm_mask_or_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29632 unsafe {
29633 let or = _mm_or_epi32(a, b).as_i32x4();
29634 transmute(simd_select_bitmask(k, or, src.as_i32x4()))
29635 }
29636}
29637
29638#[inline]
29642#[target_feature(enable = "avx512f,avx512vl")]
29643#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29644#[cfg_attr(test, assert_instr(vpord))]
29645#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29646pub const fn _mm_maskz_or_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29647 unsafe {
29648 let or = _mm_or_epi32(a, b).as_i32x4();
29649 transmute(simd_select_bitmask(k, or, i32x4::ZERO))
29650 }
29651}
29652
29653#[inline]
29657#[target_feature(enable = "avx512f")]
29658#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29659#[cfg_attr(test, assert_instr(vporq))]
29660#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29661pub const fn _mm512_or_epi64(a: __m512i, b: __m512i) -> __m512i {
29662 unsafe { transmute(simd_or(a.as_i64x8(), b.as_i64x8())) }
29663}
29664
29665#[inline]
29669#[target_feature(enable = "avx512f")]
29670#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29671#[cfg_attr(test, assert_instr(vporq))]
29672#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29673pub const fn _mm512_mask_or_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
29674 unsafe {
29675 let or = _mm512_or_epi64(a, b).as_i64x8();
29676 transmute(simd_select_bitmask(k, or, src.as_i64x8()))
29677 }
29678}
29679
29680#[inline]
29684#[target_feature(enable = "avx512f")]
29685#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29686#[cfg_attr(test, assert_instr(vporq))]
29687#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29688pub const fn _mm512_maskz_or_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
29689 unsafe {
29690 let or = _mm512_or_epi64(a, b).as_i64x8();
29691 transmute(simd_select_bitmask(k, or, i64x8::ZERO))
29692 }
29693}
29694
29695#[inline]
29699#[target_feature(enable = "avx512f,avx512vl")]
29700#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29701#[cfg_attr(test, assert_instr(vor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29703pub const fn _mm256_or_epi64(a: __m256i, b: __m256i) -> __m256i {
29704 unsafe { transmute(simd_or(a.as_i64x4(), b.as_i64x4())) }
29705}
29706
29707#[inline]
29711#[target_feature(enable = "avx512f,avx512vl")]
29712#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29713#[cfg_attr(test, assert_instr(vporq))]
29714#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29715pub const fn _mm256_mask_or_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29716 unsafe {
29717 let or = _mm256_or_epi64(a, b).as_i64x4();
29718 transmute(simd_select_bitmask(k, or, src.as_i64x4()))
29719 }
29720}
29721
29722#[inline]
29726#[target_feature(enable = "avx512f,avx512vl")]
29727#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29728#[cfg_attr(test, assert_instr(vporq))]
29729#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29730pub const fn _mm256_maskz_or_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29731 unsafe {
29732 let or = _mm256_or_epi64(a, b).as_i64x4();
29733 transmute(simd_select_bitmask(k, or, i64x4::ZERO))
29734 }
29735}
29736
29737#[inline]
29741#[target_feature(enable = "avx512f,avx512vl")]
29742#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29743#[cfg_attr(test, assert_instr(vor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29745pub const fn _mm_or_epi64(a: __m128i, b: __m128i) -> __m128i {
29746 unsafe { transmute(simd_or(a.as_i64x2(), b.as_i64x2())) }
29747}
29748
29749#[inline]
29753#[target_feature(enable = "avx512f,avx512vl")]
29754#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29755#[cfg_attr(test, assert_instr(vporq))]
29756#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29757pub const fn _mm_mask_or_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29758 unsafe {
29759 let or = _mm_or_epi64(a, b).as_i64x2();
29760 transmute(simd_select_bitmask(k, or, src.as_i64x2()))
29761 }
29762}
29763
29764#[inline]
29768#[target_feature(enable = "avx512f,avx512vl")]
29769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29770#[cfg_attr(test, assert_instr(vporq))]
29771#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29772pub const fn _mm_maskz_or_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29773 unsafe {
29774 let or = _mm_or_epi64(a, b).as_i64x2();
29775 transmute(simd_select_bitmask(k, or, i64x2::ZERO))
29776 }
29777}
29778
29779#[inline]
29783#[target_feature(enable = "avx512f")]
29784#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29785#[cfg_attr(test, assert_instr(vporq))]
29786#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29787pub const fn _mm512_or_si512(a: __m512i, b: __m512i) -> __m512i {
29788 unsafe { transmute(simd_or(a.as_i32x16(), b.as_i32x16())) }
29789}
29790
29791#[inline]
29795#[target_feature(enable = "avx512f")]
29796#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29797#[cfg_attr(test, assert_instr(vpxorq))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29799pub const fn _mm512_xor_epi32(a: __m512i, b: __m512i) -> __m512i {
29800 unsafe { transmute(simd_xor(a.as_i32x16(), b.as_i32x16())) }
29801}
29802
29803#[inline]
29807#[target_feature(enable = "avx512f")]
29808#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29809#[cfg_attr(test, assert_instr(vpxord))]
29810#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29811pub const fn _mm512_mask_xor_epi32(src: __m512i, k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
29812 unsafe {
29813 let xor = _mm512_xor_epi32(a, b).as_i32x16();
29814 transmute(simd_select_bitmask(k, xor, src.as_i32x16()))
29815 }
29816}
29817
29818#[inline]
29822#[target_feature(enable = "avx512f")]
29823#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29824#[cfg_attr(test, assert_instr(vpxord))]
29825#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29826pub const fn _mm512_maskz_xor_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
29827 unsafe {
29828 let xor = _mm512_xor_epi32(a, b).as_i32x16();
29829 transmute(simd_select_bitmask(k, xor, i32x16::ZERO))
29830 }
29831}
29832
29833#[inline]
29837#[target_feature(enable = "avx512f,avx512vl")]
29838#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29839#[cfg_attr(test, assert_instr(vxor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29841pub const fn _mm256_xor_epi32(a: __m256i, b: __m256i) -> __m256i {
29842 unsafe { transmute(simd_xor(a.as_i32x8(), b.as_i32x8())) }
29843}
29844
29845#[inline]
29849#[target_feature(enable = "avx512f,avx512vl")]
29850#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29851#[cfg_attr(test, assert_instr(vpxord))]
29852#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29853pub const fn _mm256_mask_xor_epi32(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29854 unsafe {
29855 let xor = _mm256_xor_epi32(a, b).as_i32x8();
29856 transmute(simd_select_bitmask(k, xor, src.as_i32x8()))
29857 }
29858}
29859
29860#[inline]
29864#[target_feature(enable = "avx512f,avx512vl")]
29865#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29866#[cfg_attr(test, assert_instr(vpxord))]
29867#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29868pub const fn _mm256_maskz_xor_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29869 unsafe {
29870 let xor = _mm256_xor_epi32(a, b).as_i32x8();
29871 transmute(simd_select_bitmask(k, xor, i32x8::ZERO))
29872 }
29873}
29874
29875#[inline]
29879#[target_feature(enable = "avx512f,avx512vl")]
29880#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29881#[cfg_attr(test, assert_instr(vxor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29883pub const fn _mm_xor_epi32(a: __m128i, b: __m128i) -> __m128i {
29884 unsafe { transmute(simd_xor(a.as_i32x4(), b.as_i32x4())) }
29885}
29886
29887#[inline]
29891#[target_feature(enable = "avx512f,avx512vl")]
29892#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29893#[cfg_attr(test, assert_instr(vpxord))]
29894#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29895pub const fn _mm_mask_xor_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29896 unsafe {
29897 let xor = _mm_xor_epi32(a, b).as_i32x4();
29898 transmute(simd_select_bitmask(k, xor, src.as_i32x4()))
29899 }
29900}
29901
29902#[inline]
29906#[target_feature(enable = "avx512f,avx512vl")]
29907#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29908#[cfg_attr(test, assert_instr(vpxord))]
29909#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29910pub const fn _mm_maskz_xor_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
29911 unsafe {
29912 let xor = _mm_xor_epi32(a, b).as_i32x4();
29913 transmute(simd_select_bitmask(k, xor, i32x4::ZERO))
29914 }
29915}
29916
29917#[inline]
29921#[target_feature(enable = "avx512f")]
29922#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29923#[cfg_attr(test, assert_instr(vpxorq))]
29924#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29925pub const fn _mm512_xor_epi64(a: __m512i, b: __m512i) -> __m512i {
29926 unsafe { transmute(simd_xor(a.as_i64x8(), b.as_i64x8())) }
29927}
29928
29929#[inline]
29933#[target_feature(enable = "avx512f")]
29934#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29935#[cfg_attr(test, assert_instr(vpxorq))]
29936#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29937pub const fn _mm512_mask_xor_epi64(src: __m512i, k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
29938 unsafe {
29939 let xor = _mm512_xor_epi64(a, b).as_i64x8();
29940 transmute(simd_select_bitmask(k, xor, src.as_i64x8()))
29941 }
29942}
29943
29944#[inline]
29948#[target_feature(enable = "avx512f")]
29949#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29950#[cfg_attr(test, assert_instr(vpxorq))]
29951#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29952pub const fn _mm512_maskz_xor_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
29953 unsafe {
29954 let xor = _mm512_xor_epi64(a, b).as_i64x8();
29955 transmute(simd_select_bitmask(k, xor, i64x8::ZERO))
29956 }
29957}
29958
29959#[inline]
29963#[target_feature(enable = "avx512f,avx512vl")]
29964#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29965#[cfg_attr(test, assert_instr(vxor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29967pub const fn _mm256_xor_epi64(a: __m256i, b: __m256i) -> __m256i {
29968 unsafe { transmute(simd_xor(a.as_i64x4(), b.as_i64x4())) }
29969}
29970
29971#[inline]
29975#[target_feature(enable = "avx512f,avx512vl")]
29976#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29977#[cfg_attr(test, assert_instr(vpxorq))]
29978#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29979pub const fn _mm256_mask_xor_epi64(src: __m256i, k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29980 unsafe {
29981 let xor = _mm256_xor_epi64(a, b).as_i64x4();
29982 transmute(simd_select_bitmask(k, xor, src.as_i64x4()))
29983 }
29984}
29985
29986#[inline]
29990#[target_feature(enable = "avx512f,avx512vl")]
29991#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
29992#[cfg_attr(test, assert_instr(vpxorq))]
29993#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
29994pub const fn _mm256_maskz_xor_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
29995 unsafe {
29996 let xor = _mm256_xor_epi64(a, b).as_i64x4();
29997 transmute(simd_select_bitmask(k, xor, i64x4::ZERO))
29998 }
29999}
30000
30001#[inline]
30005#[target_feature(enable = "avx512f,avx512vl")]
30006#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30007#[cfg_attr(test, assert_instr(vxor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30009pub const fn _mm_xor_epi64(a: __m128i, b: __m128i) -> __m128i {
30010 unsafe { transmute(simd_xor(a.as_i64x2(), b.as_i64x2())) }
30011}
30012
30013#[inline]
30017#[target_feature(enable = "avx512f,avx512vl")]
30018#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30019#[cfg_attr(test, assert_instr(vpxorq))]
30020#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30021pub const fn _mm_mask_xor_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
30022 unsafe {
30023 let xor = _mm_xor_epi64(a, b).as_i64x2();
30024 transmute(simd_select_bitmask(k, xor, src.as_i64x2()))
30025 }
30026}
30027
30028#[inline]
30032#[target_feature(enable = "avx512f,avx512vl")]
30033#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30034#[cfg_attr(test, assert_instr(vpxorq))]
30035#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30036pub const fn _mm_maskz_xor_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
30037 unsafe {
30038 let xor = _mm_xor_epi64(a, b).as_i64x2();
30039 transmute(simd_select_bitmask(k, xor, i64x2::ZERO))
30040 }
30041}
30042
30043#[inline]
30047#[target_feature(enable = "avx512f")]
30048#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30049#[cfg_attr(test, assert_instr(vpxorq))]
30050#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30051pub const fn _mm512_xor_si512(a: __m512i, b: __m512i) -> __m512i {
30052 unsafe { transmute(simd_xor(a.as_i32x16(), b.as_i32x16())) }
30053}
30054
30055#[inline]
30059#[target_feature(enable = "avx512f")]
30060#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30061#[cfg_attr(test, assert_instr(vpandnq))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30063pub const fn _mm512_andnot_epi32(a: __m512i, b: __m512i) -> __m512i {
30064 _mm512_and_epi32(_mm512_xor_epi32(a, _mm512_set1_epi32(u32::MAX as i32)), b)
30065}
30066
30067#[inline]
30071#[target_feature(enable = "avx512f")]
30072#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30073#[cfg_attr(test, assert_instr(vpandnd))]
30074#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30075pub const fn _mm512_mask_andnot_epi32(
30076 src: __m512i,
30077 k: __mmask16,
30078 a: __m512i,
30079 b: __m512i,
30080) -> __m512i {
30081 unsafe {
30082 let andnot = _mm512_andnot_epi32(a, b).as_i32x16();
30083 transmute(simd_select_bitmask(k, andnot, src.as_i32x16()))
30084 }
30085}
30086
30087#[inline]
30091#[target_feature(enable = "avx512f")]
30092#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30093#[cfg_attr(test, assert_instr(vpandnd))]
30094#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30095pub const fn _mm512_maskz_andnot_epi32(k: __mmask16, a: __m512i, b: __m512i) -> __m512i {
30096 unsafe {
30097 let andnot = _mm512_andnot_epi32(a, b).as_i32x16();
30098 transmute(simd_select_bitmask(k, andnot, i32x16::ZERO))
30099 }
30100}
30101
30102#[inline]
30106#[target_feature(enable = "avx512f,avx512vl")]
30107#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30108#[cfg_attr(test, assert_instr(vpandnd))]
30109#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30110pub const fn _mm256_mask_andnot_epi32(
30111 src: __m256i,
30112 k: __mmask8,
30113 a: __m256i,
30114 b: __m256i,
30115) -> __m256i {
30116 unsafe {
30117 let not = _mm256_xor_epi32(a, _mm256_set1_epi32(u32::MAX as i32));
30118 let andnot = simd_and(not.as_i32x8(), b.as_i32x8());
30119 transmute(simd_select_bitmask(k, andnot, src.as_i32x8()))
30120 }
30121}
30122
30123#[inline]
30127#[target_feature(enable = "avx512f,avx512vl")]
30128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30129#[cfg_attr(test, assert_instr(vpandnd))]
30130#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30131pub const fn _mm256_maskz_andnot_epi32(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
30132 unsafe {
30133 let not = _mm256_xor_epi32(a, _mm256_set1_epi32(u32::MAX as i32));
30134 let andnot = simd_and(not.as_i32x8(), b.as_i32x8());
30135 transmute(simd_select_bitmask(k, andnot, i32x8::ZERO))
30136 }
30137}
30138
30139#[inline]
30143#[target_feature(enable = "avx512f,avx512vl")]
30144#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30145#[cfg_attr(test, assert_instr(vpandnd))]
30146#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30147pub const fn _mm_mask_andnot_epi32(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
30148 unsafe {
30149 let not = _mm_xor_epi32(a, _mm_set1_epi32(u32::MAX as i32));
30150 let andnot = simd_and(not.as_i32x4(), b.as_i32x4());
30151 transmute(simd_select_bitmask(k, andnot, src.as_i32x4()))
30152 }
30153}
30154
30155#[inline]
30159#[target_feature(enable = "avx512f,avx512vl")]
30160#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30161#[cfg_attr(test, assert_instr(vpandnd))]
30162#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30163pub const fn _mm_maskz_andnot_epi32(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
30164 unsafe {
30165 let not = _mm_xor_epi32(a, _mm_set1_epi32(u32::MAX as i32));
30166 let andnot = simd_and(not.as_i32x4(), b.as_i32x4());
30167 transmute(simd_select_bitmask(k, andnot, i32x4::ZERO))
30168 }
30169}
30170
30171#[inline]
30175#[target_feature(enable = "avx512f")]
30176#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30177#[cfg_attr(test, assert_instr(vpandnq))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30179pub const fn _mm512_andnot_epi64(a: __m512i, b: __m512i) -> __m512i {
30180 _mm512_and_epi64(_mm512_xor_epi64(a, _mm512_set1_epi64(u64::MAX as i64)), b)
30181}
30182
30183#[inline]
30187#[target_feature(enable = "avx512f")]
30188#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30189#[cfg_attr(test, assert_instr(vpandnq))]
30190#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30191pub const fn _mm512_mask_andnot_epi64(
30192 src: __m512i,
30193 k: __mmask8,
30194 a: __m512i,
30195 b: __m512i,
30196) -> __m512i {
30197 unsafe {
30198 let andnot = _mm512_andnot_epi64(a, b).as_i64x8();
30199 transmute(simd_select_bitmask(k, andnot, src.as_i64x8()))
30200 }
30201}
30202
30203#[inline]
30207#[target_feature(enable = "avx512f")]
30208#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30209#[cfg_attr(test, assert_instr(vpandnq))]
30210#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30211pub const fn _mm512_maskz_andnot_epi64(k: __mmask8, a: __m512i, b: __m512i) -> __m512i {
30212 unsafe {
30213 let andnot = _mm512_andnot_epi64(a, b).as_i64x8();
30214 transmute(simd_select_bitmask(k, andnot, i64x8::ZERO))
30215 }
30216}
30217
30218#[inline]
30222#[target_feature(enable = "avx512f,avx512vl")]
30223#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30224#[cfg_attr(test, assert_instr(vpandnq))]
30225#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30226pub const fn _mm256_mask_andnot_epi64(
30227 src: __m256i,
30228 k: __mmask8,
30229 a: __m256i,
30230 b: __m256i,
30231) -> __m256i {
30232 unsafe {
30233 let not = _mm256_xor_epi64(a, _mm256_set1_epi64x(u64::MAX as i64));
30234 let andnot = simd_and(not.as_i64x4(), b.as_i64x4());
30235 transmute(simd_select_bitmask(k, andnot, src.as_i64x4()))
30236 }
30237}
30238
30239#[inline]
30243#[target_feature(enable = "avx512f,avx512vl")]
30244#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30245#[cfg_attr(test, assert_instr(vpandnq))]
30246#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30247pub const fn _mm256_maskz_andnot_epi64(k: __mmask8, a: __m256i, b: __m256i) -> __m256i {
30248 unsafe {
30249 let not = _mm256_xor_epi64(a, _mm256_set1_epi64x(u64::MAX as i64));
30250 let andnot = simd_and(not.as_i64x4(), b.as_i64x4());
30251 transmute(simd_select_bitmask(k, andnot, i64x4::ZERO))
30252 }
30253}
30254
30255#[inline]
30259#[target_feature(enable = "avx512f,avx512vl")]
30260#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30261#[cfg_attr(test, assert_instr(vpandnq))]
30262#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30263pub const fn _mm_mask_andnot_epi64(src: __m128i, k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
30264 unsafe {
30265 let not = _mm_xor_epi64(a, _mm_set1_epi64x(u64::MAX as i64));
30266 let andnot = simd_and(not.as_i64x2(), b.as_i64x2());
30267 transmute(simd_select_bitmask(k, andnot, src.as_i64x2()))
30268 }
30269}
30270
30271#[inline]
30275#[target_feature(enable = "avx512f,avx512vl")]
30276#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30277#[cfg_attr(test, assert_instr(vpandnq))]
30278#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30279pub const fn _mm_maskz_andnot_epi64(k: __mmask8, a: __m128i, b: __m128i) -> __m128i {
30280 unsafe {
30281 let not = _mm_xor_epi64(a, _mm_set1_epi64x(u64::MAX as i64));
30282 let andnot = simd_and(not.as_i64x2(), b.as_i64x2());
30283 transmute(simd_select_bitmask(k, andnot, i64x2::ZERO))
30284 }
30285}
30286
30287#[inline]
30291#[target_feature(enable = "avx512f")]
30292#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30293#[cfg_attr(test, assert_instr(vpandnq))]
30294#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30295pub const fn _mm512_andnot_si512(a: __m512i, b: __m512i) -> __m512i {
30296 _mm512_and_epi64(_mm512_xor_epi64(a, _mm512_set1_epi64(u64::MAX as i64)), b)
30297}
30298
30299#[inline]
30303#[target_feature(enable = "avx512f")]
30304#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30305#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30306pub const fn _cvtmask16_u32(a: __mmask16) -> u32 {
30307 a as u32
30308}
30309
30310#[inline]
30314#[target_feature(enable = "avx512f")]
30315#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30316#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30317pub const fn _cvtu32_mask16(a: u32) -> __mmask16 {
30318 a as __mmask16
30319}
30320
30321#[inline]
30325#[target_feature(enable = "avx512f")]
30326#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30327#[cfg_attr(test, assert_instr(and))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30329pub const fn _kand_mask16(a: __mmask16, b: __mmask16) -> __mmask16 {
30330 a & b
30331}
30332
30333#[inline]
30337#[target_feature(enable = "avx512f")]
30338#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30339#[cfg_attr(test, assert_instr(and))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30341pub const fn _mm512_kand(a: __mmask16, b: __mmask16) -> __mmask16 {
30342 a & b
30343}
30344
30345#[inline]
30349#[target_feature(enable = "avx512f")]
30350#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30351#[cfg_attr(test, assert_instr(or))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30353pub const fn _kor_mask16(a: __mmask16, b: __mmask16) -> __mmask16 {
30354 a | b
30355}
30356
30357#[inline]
30361#[target_feature(enable = "avx512f")]
30362#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30363#[cfg_attr(test, assert_instr(or))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30365pub const fn _mm512_kor(a: __mmask16, b: __mmask16) -> __mmask16 {
30366 a | b
30367}
30368
30369#[inline]
30373#[target_feature(enable = "avx512f")]
30374#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30375#[cfg_attr(test, assert_instr(xor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30377pub const fn _kxor_mask16(a: __mmask16, b: __mmask16) -> __mmask16 {
30378 a ^ b
30379}
30380
30381#[inline]
30385#[target_feature(enable = "avx512f")]
30386#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30387#[cfg_attr(test, assert_instr(xor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30389pub const fn _mm512_kxor(a: __mmask16, b: __mmask16) -> __mmask16 {
30390 a ^ b
30391}
30392
30393#[inline]
30397#[target_feature(enable = "avx512f")]
30398#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30399#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30400pub const fn _knot_mask16(a: __mmask16) -> __mmask16 {
30401 a ^ 0b11111111_11111111
30402}
30403
30404#[inline]
30408#[target_feature(enable = "avx512f")]
30409#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30410#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30411pub const fn _mm512_knot(a: __mmask16) -> __mmask16 {
30412 a ^ 0b11111111_11111111
30413}
30414
30415#[inline]
30419#[target_feature(enable = "avx512f")]
30420#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30421#[cfg_attr(test, assert_instr(not))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30423pub const fn _kandn_mask16(a: __mmask16, b: __mmask16) -> __mmask16 {
30424 _mm512_kand(_mm512_knot(a), b)
30425}
30426
30427#[inline]
30431#[target_feature(enable = "avx512f")]
30432#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30433#[cfg_attr(test, assert_instr(not))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30435pub const fn _mm512_kandn(a: __mmask16, b: __mmask16) -> __mmask16 {
30436 _mm512_kand(_mm512_knot(a), b)
30437}
30438
30439#[inline]
30443#[target_feature(enable = "avx512f")]
30444#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30445#[cfg_attr(test, assert_instr(xor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30447pub const fn _kxnor_mask16(a: __mmask16, b: __mmask16) -> __mmask16 {
30448 _mm512_knot(_mm512_kxor(a, b))
30449}
30450
30451#[inline]
30455#[target_feature(enable = "avx512f")]
30456#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30457#[cfg_attr(test, assert_instr(xor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30459pub const fn _mm512_kxnor(a: __mmask16, b: __mmask16) -> __mmask16 {
30460 _mm512_knot(_mm512_kxor(a, b))
30461}
30462
30463#[inline]
30468#[target_feature(enable = "avx512f")]
30469#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30470#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30471pub const unsafe fn _kortest_mask16_u8(a: __mmask16, b: __mmask16, all_ones: *mut u8) -> u8 {
30472 let tmp = _kor_mask16(a, b);
30473 *all_ones = (tmp == 0xffff) as u8;
30474 (tmp == 0) as u8
30475}
30476
30477#[inline]
30482#[target_feature(enable = "avx512f")]
30483#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30484#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30485pub const fn _kortestc_mask16_u8(a: __mmask16, b: __mmask16) -> u8 {
30486 (_kor_mask16(a, b) == 0xffff) as u8
30487}
30488
30489#[inline]
30494#[target_feature(enable = "avx512f")]
30495#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30496#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30497pub const fn _kortestz_mask16_u8(a: __mmask16, b: __mmask16) -> u8 {
30498 (_kor_mask16(a, b) == 0) as u8
30499}
30500
30501#[inline]
30505#[target_feature(enable = "avx512f")]
30506#[rustc_legacy_const_generics(1)]
30507#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30508#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30509pub const fn _kshiftli_mask16<const COUNT: u32>(a: __mmask16) -> __mmask16 {
30510 a.unbounded_shl(COUNT)
30511}
30512
30513#[inline]
30517#[target_feature(enable = "avx512f")]
30518#[rustc_legacy_const_generics(1)]
30519#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30520#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30521pub const fn _kshiftri_mask16<const COUNT: u32>(a: __mmask16) -> __mmask16 {
30522 a.unbounded_shr(COUNT)
30523}
30524
30525#[inline]
30529#[target_feature(enable = "avx512f")]
30530#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30531#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30532pub const unsafe fn _load_mask16(mem_addr: *const __mmask16) -> __mmask16 {
30533 *mem_addr
30534}
30535
30536#[inline]
30540#[target_feature(enable = "avx512f")]
30541#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30542#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30543pub const unsafe fn _store_mask16(mem_addr: *mut __mmask16, a: __mmask16) {
30544 *mem_addr = a;
30545}
30546
30547#[inline]
30551#[target_feature(enable = "avx512f")]
30552#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30553#[cfg_attr(test, assert_instr(mov))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30555pub const fn _mm512_kmov(a: __mmask16) -> __mmask16 {
30556 a
30557}
30558
30559#[inline]
30563#[target_feature(enable = "avx512f")] #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30565#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30566pub const fn _mm512_int2mask(mask: i32) -> __mmask16 {
30567 mask as u16
30568}
30569
30570#[inline]
30574#[target_feature(enable = "avx512f")]
30575#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30576#[cfg_attr(test, assert_instr(mov))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30578pub const fn _mm512_mask2int(k1: __mmask16) -> i32 {
30579 k1 as i32
30580}
30581
30582#[inline]
30586#[target_feature(enable = "avx512f")]
30587#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30588#[cfg_attr(test, assert_instr(mov))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30590pub const fn _mm512_kunpackb(a: __mmask16, b: __mmask16) -> __mmask16 {
30591 ((a & 0xff) << 8) | (b & 0xff)
30592}
30593
30594#[inline]
30598#[target_feature(enable = "avx512f")]
30599#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30600#[cfg_attr(test, assert_instr(cmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30602pub const fn _mm512_kortestc(a: __mmask16, b: __mmask16) -> i32 {
30603 let r = (a | b) == 0b11111111_11111111;
30604 r as i32
30605}
30606
30607#[inline]
30611#[target_feature(enable = "avx512f")]
30612#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30613#[cfg_attr(test, assert_instr(xor))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30615pub const fn _mm512_kortestz(a: __mmask16, b: __mmask16) -> i32 {
30616 let r = (a | b) == 0;
30617 r as i32
30618}
30619
30620#[inline]
30624#[target_feature(enable = "avx512f")]
30625#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30626#[cfg_attr(test, assert_instr(vptestmd))]
30627#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30628pub const fn _mm512_test_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
30629 let and = _mm512_and_epi32(a, b);
30630 let zero = _mm512_setzero_si512();
30631 _mm512_cmpneq_epi32_mask(and, zero)
30632}
30633
30634#[inline]
30638#[target_feature(enable = "avx512f")]
30639#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30640#[cfg_attr(test, assert_instr(vptestmd))]
30641#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30642pub const fn _mm512_mask_test_epi32_mask(k: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
30643 let and = _mm512_and_epi32(a, b);
30644 let zero = _mm512_setzero_si512();
30645 _mm512_mask_cmpneq_epi32_mask(k, and, zero)
30646}
30647
30648#[inline]
30652#[target_feature(enable = "avx512f,avx512vl")]
30653#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30654#[cfg_attr(test, assert_instr(vptestmd))]
30655#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30656pub const fn _mm256_test_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
30657 let and = _mm256_and_si256(a, b);
30658 let zero = _mm256_setzero_si256();
30659 _mm256_cmpneq_epi32_mask(and, zero)
30660}
30661
30662#[inline]
30666#[target_feature(enable = "avx512f,avx512vl")]
30667#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30668#[cfg_attr(test, assert_instr(vptestmd))]
30669#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30670pub const fn _mm256_mask_test_epi32_mask(k: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
30671 let and = _mm256_and_si256(a, b);
30672 let zero = _mm256_setzero_si256();
30673 _mm256_mask_cmpneq_epi32_mask(k, and, zero)
30674}
30675
30676#[inline]
30680#[target_feature(enable = "avx512f,avx512vl")]
30681#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30682#[cfg_attr(test, assert_instr(vptestmd))]
30683#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30684pub const fn _mm_test_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
30685 let and = _mm_and_si128(a, b);
30686 let zero = _mm_setzero_si128();
30687 _mm_cmpneq_epi32_mask(and, zero)
30688}
30689
30690#[inline]
30694#[target_feature(enable = "avx512f,avx512vl")]
30695#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30696#[cfg_attr(test, assert_instr(vptestmd))]
30697#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30698pub const fn _mm_mask_test_epi32_mask(k: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
30699 let and = _mm_and_si128(a, b);
30700 let zero = _mm_setzero_si128();
30701 _mm_mask_cmpneq_epi32_mask(k, and, zero)
30702}
30703
30704#[inline]
30708#[target_feature(enable = "avx512f")]
30709#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30710#[cfg_attr(test, assert_instr(vptestmq))]
30711#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30712pub const fn _mm512_test_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
30713 let and = _mm512_and_epi64(a, b);
30714 let zero = _mm512_setzero_si512();
30715 _mm512_cmpneq_epi64_mask(and, zero)
30716}
30717
30718#[inline]
30722#[target_feature(enable = "avx512f")]
30723#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30724#[cfg_attr(test, assert_instr(vptestmq))]
30725#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30726pub const fn _mm512_mask_test_epi64_mask(k: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
30727 let and = _mm512_and_epi64(a, b);
30728 let zero = _mm512_setzero_si512();
30729 _mm512_mask_cmpneq_epi64_mask(k, and, zero)
30730}
30731
30732#[inline]
30736#[target_feature(enable = "avx512f,avx512vl")]
30737#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30738#[cfg_attr(test, assert_instr(vptestmq))]
30739#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30740pub const fn _mm256_test_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
30741 let and = _mm256_and_si256(a, b);
30742 let zero = _mm256_setzero_si256();
30743 _mm256_cmpneq_epi64_mask(and, zero)
30744}
30745
30746#[inline]
30750#[target_feature(enable = "avx512f,avx512vl")]
30751#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30752#[cfg_attr(test, assert_instr(vptestmq))]
30753#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30754pub const fn _mm256_mask_test_epi64_mask(k: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
30755 let and = _mm256_and_si256(a, b);
30756 let zero = _mm256_setzero_si256();
30757 _mm256_mask_cmpneq_epi64_mask(k, and, zero)
30758}
30759
30760#[inline]
30764#[target_feature(enable = "avx512f,avx512vl")]
30765#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30766#[cfg_attr(test, assert_instr(vptestmq))]
30767#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30768pub const fn _mm_test_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
30769 let and = _mm_and_si128(a, b);
30770 let zero = _mm_setzero_si128();
30771 _mm_cmpneq_epi64_mask(and, zero)
30772}
30773
30774#[inline]
30778#[target_feature(enable = "avx512f,avx512vl")]
30779#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30780#[cfg_attr(test, assert_instr(vptestmq))]
30781#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30782pub const fn _mm_mask_test_epi64_mask(k: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
30783 let and = _mm_and_si128(a, b);
30784 let zero = _mm_setzero_si128();
30785 _mm_mask_cmpneq_epi64_mask(k, and, zero)
30786}
30787
30788#[inline]
30792#[target_feature(enable = "avx512f")]
30793#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30794#[cfg_attr(test, assert_instr(vptestnmd))]
30795#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30796pub const fn _mm512_testn_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
30797 let and = _mm512_and_epi32(a, b);
30798 let zero = _mm512_setzero_si512();
30799 _mm512_cmpeq_epi32_mask(and, zero)
30800}
30801
30802#[inline]
30806#[target_feature(enable = "avx512f")]
30807#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30808#[cfg_attr(test, assert_instr(vptestnmd))]
30809#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30810pub const fn _mm512_mask_testn_epi32_mask(k: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
30811 let and = _mm512_and_epi32(a, b);
30812 let zero = _mm512_setzero_si512();
30813 _mm512_mask_cmpeq_epi32_mask(k, and, zero)
30814}
30815
30816#[inline]
30820#[target_feature(enable = "avx512f,avx512vl")]
30821#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30822#[cfg_attr(test, assert_instr(vptestnmd))]
30823#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30824pub const fn _mm256_testn_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
30825 let and = _mm256_and_si256(a, b);
30826 let zero = _mm256_setzero_si256();
30827 _mm256_cmpeq_epi32_mask(and, zero)
30828}
30829
30830#[inline]
30834#[target_feature(enable = "avx512f,avx512vl")]
30835#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30836#[cfg_attr(test, assert_instr(vptestnmd))]
30837#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30838pub const fn _mm256_mask_testn_epi32_mask(k: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
30839 let and = _mm256_and_si256(a, b);
30840 let zero = _mm256_setzero_si256();
30841 _mm256_mask_cmpeq_epi32_mask(k, and, zero)
30842}
30843
30844#[inline]
30848#[target_feature(enable = "avx512f,avx512vl")]
30849#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30850#[cfg_attr(test, assert_instr(vptestnmd))]
30851#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30852pub const fn _mm_testn_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
30853 let and = _mm_and_si128(a, b);
30854 let zero = _mm_setzero_si128();
30855 _mm_cmpeq_epi32_mask(and, zero)
30856}
30857
30858#[inline]
30862#[target_feature(enable = "avx512f,avx512vl")]
30863#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30864#[cfg_attr(test, assert_instr(vptestnmd))]
30865#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30866pub const fn _mm_mask_testn_epi32_mask(k: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
30867 let and = _mm_and_si128(a, b);
30868 let zero = _mm_setzero_si128();
30869 _mm_mask_cmpeq_epi32_mask(k, and, zero)
30870}
30871
30872#[inline]
30876#[target_feature(enable = "avx512f")]
30877#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30878#[cfg_attr(test, assert_instr(vptestnmq))]
30879#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30880pub const fn _mm512_testn_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
30881 let and = _mm512_and_epi64(a, b);
30882 let zero = _mm512_setzero_si512();
30883 _mm512_cmpeq_epi64_mask(and, zero)
30884}
30885
30886#[inline]
30890#[target_feature(enable = "avx512f")]
30891#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30892#[cfg_attr(test, assert_instr(vptestnmq))]
30893#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30894pub const fn _mm512_mask_testn_epi64_mask(k: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
30895 let and = _mm512_and_epi64(a, b);
30896 let zero = _mm512_setzero_si512();
30897 _mm512_mask_cmpeq_epi64_mask(k, and, zero)
30898}
30899
30900#[inline]
30904#[target_feature(enable = "avx512f,avx512vl")]
30905#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30906#[cfg_attr(test, assert_instr(vptestnmq))]
30907#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30908pub const fn _mm256_testn_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
30909 let and = _mm256_and_si256(a, b);
30910 let zero = _mm256_setzero_si256();
30911 _mm256_cmpeq_epi64_mask(and, zero)
30912}
30913
30914#[inline]
30918#[target_feature(enable = "avx512f,avx512vl")]
30919#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30920#[cfg_attr(test, assert_instr(vptestnmq))]
30921#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30922pub const fn _mm256_mask_testn_epi64_mask(k: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
30923 let and = _mm256_and_si256(a, b);
30924 let zero = _mm256_setzero_si256();
30925 _mm256_mask_cmpeq_epi64_mask(k, and, zero)
30926}
30927
30928#[inline]
30932#[target_feature(enable = "avx512f,avx512vl")]
30933#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30934#[cfg_attr(test, assert_instr(vptestnmq))]
30935#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30936pub const fn _mm_testn_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
30937 let and = _mm_and_si128(a, b);
30938 let zero = _mm_setzero_si128();
30939 _mm_cmpeq_epi64_mask(and, zero)
30940}
30941
30942#[inline]
30946#[target_feature(enable = "avx512f,avx512vl")]
30947#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30948#[cfg_attr(test, assert_instr(vptestnmq))]
30949#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
30950pub const fn _mm_mask_testn_epi64_mask(k: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
30951 let and = _mm_and_si128(a, b);
30952 let zero = _mm_setzero_si128();
30953 _mm_mask_cmpeq_epi64_mask(k, and, zero)
30954}
30955
30956#[inline]
30969#[target_feature(enable = "avx512f")]
30970#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30971#[cfg_attr(test, assert_instr(vmovntps))]
30972#[allow(clippy::cast_ptr_alignment)]
30973pub unsafe fn _mm512_stream_ps(mem_addr: *mut f32, a: __m512) {
30974 crate::arch::asm!(
30976 vps!("vmovntps", ",{a}"),
30977 p = in(reg) mem_addr,
30978 a = in(zmm_reg) a,
30979 options(nostack, preserves_flags),
30980 );
30981}
30982
30983#[inline]
30996#[target_feature(enable = "avx512f")]
30997#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
30998#[cfg_attr(test, assert_instr(vmovntpd))]
30999#[allow(clippy::cast_ptr_alignment)]
31000pub unsafe fn _mm512_stream_pd(mem_addr: *mut f64, a: __m512d) {
31001 crate::arch::asm!(
31003 vps!("vmovntpd", ",{a}"),
31004 p = in(reg) mem_addr,
31005 a = in(zmm_reg) a,
31006 options(nostack, preserves_flags),
31007 );
31008}
31009
31010#[inline]
31023#[target_feature(enable = "avx512f")]
31024#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31025#[cfg_attr(test, assert_instr(vmovntdq))]
31026#[allow(clippy::cast_ptr_alignment)]
31027pub unsafe fn _mm512_stream_si512(mem_addr: *mut __m512i, a: __m512i) {
31028 crate::arch::asm!(
31030 vps!("vmovntdq", ",{a}"),
31031 p = in(reg) mem_addr,
31032 a = in(zmm_reg) a,
31033 options(nostack, preserves_flags),
31034 );
31035}
31036
31037#[inline]
31043#[target_feature(enable = "avx512f")]
31044#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31045pub unsafe fn _mm512_stream_load_si512(mem_addr: *const __m512i) -> __m512i {
31046 let dst: __m512i;
31047 crate::arch::asm!(
31048 vpl!("vmovntdqa {a}"),
31049 a = out(zmm_reg) dst,
31050 p = in(reg) mem_addr,
31051 options(pure, readonly, nostack, preserves_flags),
31052 );
31053 dst
31054}
31055
31056#[inline]
31060#[target_feature(enable = "avx512f")]
31061#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31062#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31063pub const fn _mm512_set_ps(
31064 e0: f32,
31065 e1: f32,
31066 e2: f32,
31067 e3: f32,
31068 e4: f32,
31069 e5: f32,
31070 e6: f32,
31071 e7: f32,
31072 e8: f32,
31073 e9: f32,
31074 e10: f32,
31075 e11: f32,
31076 e12: f32,
31077 e13: f32,
31078 e14: f32,
31079 e15: f32,
31080) -> __m512 {
31081 _mm512_setr_ps(
31082 e15, e14, e13, e12, e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0,
31083 )
31084}
31085
31086#[inline]
31091#[target_feature(enable = "avx512f")]
31092#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31093#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31094pub const fn _mm512_setr_ps(
31095 e0: f32,
31096 e1: f32,
31097 e2: f32,
31098 e3: f32,
31099 e4: f32,
31100 e5: f32,
31101 e6: f32,
31102 e7: f32,
31103 e8: f32,
31104 e9: f32,
31105 e10: f32,
31106 e11: f32,
31107 e12: f32,
31108 e13: f32,
31109 e14: f32,
31110 e15: f32,
31111) -> __m512 {
31112 unsafe {
31113 let r = f32x16::new(
31114 e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15,
31115 );
31116 transmute(r)
31117 }
31118}
31119
31120#[inline]
31124#[target_feature(enable = "avx512f")]
31125#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31126#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31127pub const fn _mm512_set1_pd(a: f64) -> __m512d {
31128 unsafe { transmute(f64x8::splat(a)) }
31129}
31130
31131#[inline]
31135#[target_feature(enable = "avx512f")]
31136#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31137#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31138pub const fn _mm512_set1_ps(a: f32) -> __m512 {
31139 unsafe { transmute(f32x16::splat(a)) }
31140}
31141
31142#[inline]
31146#[target_feature(enable = "avx512f")]
31147#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31148#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31149pub const fn _mm512_set_epi32(
31150 e15: i32,
31151 e14: i32,
31152 e13: i32,
31153 e12: i32,
31154 e11: i32,
31155 e10: i32,
31156 e9: i32,
31157 e8: i32,
31158 e7: i32,
31159 e6: i32,
31160 e5: i32,
31161 e4: i32,
31162 e3: i32,
31163 e2: i32,
31164 e1: i32,
31165 e0: i32,
31166) -> __m512i {
31167 _mm512_setr_epi32(
31168 e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15,
31169 )
31170}
31171
31172#[inline]
31176#[target_feature(enable = "avx512f")]
31177#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31178#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31179pub const fn _mm512_set1_epi8(a: i8) -> __m512i {
31180 unsafe { transmute(i8x64::splat(a)) }
31181}
31182
31183#[inline]
31187#[target_feature(enable = "avx512f")]
31188#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31189#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31190pub const fn _mm512_set1_epi16(a: i16) -> __m512i {
31191 unsafe { transmute(i16x32::splat(a)) }
31192}
31193
31194#[inline]
31198#[target_feature(enable = "avx512f")]
31199#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31200#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31201pub const fn _mm512_set1_epi32(a: i32) -> __m512i {
31202 unsafe { transmute(i32x16::splat(a)) }
31203}
31204
31205#[inline]
31209#[target_feature(enable = "avx512f")]
31210#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31211#[cfg_attr(test, assert_instr(vpbroadcastd))]
31212#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31213pub const fn _mm512_mask_set1_epi32(src: __m512i, k: __mmask16, a: i32) -> __m512i {
31214 unsafe {
31215 let r = _mm512_set1_epi32(a).as_i32x16();
31216 transmute(simd_select_bitmask(k, r, src.as_i32x16()))
31217 }
31218}
31219
31220#[inline]
31224#[target_feature(enable = "avx512f")]
31225#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31226#[cfg_attr(test, assert_instr(vpbroadcastd))]
31227#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31228pub const fn _mm512_maskz_set1_epi32(k: __mmask16, a: i32) -> __m512i {
31229 unsafe {
31230 let r = _mm512_set1_epi32(a).as_i32x16();
31231 transmute(simd_select_bitmask(k, r, i32x16::ZERO))
31232 }
31233}
31234
31235#[inline]
31239#[target_feature(enable = "avx512f,avx512vl")]
31240#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31241#[cfg_attr(test, assert_instr(vpbroadcastd))]
31242#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31243pub const fn _mm256_mask_set1_epi32(src: __m256i, k: __mmask8, a: i32) -> __m256i {
31244 unsafe {
31245 let r = _mm256_set1_epi32(a).as_i32x8();
31246 transmute(simd_select_bitmask(k, r, src.as_i32x8()))
31247 }
31248}
31249
31250#[inline]
31254#[target_feature(enable = "avx512f,avx512vl")]
31255#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31256#[cfg_attr(test, assert_instr(vpbroadcastd))]
31257#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31258pub const fn _mm256_maskz_set1_epi32(k: __mmask8, a: i32) -> __m256i {
31259 unsafe {
31260 let r = _mm256_set1_epi32(a).as_i32x8();
31261 transmute(simd_select_bitmask(k, r, i32x8::ZERO))
31262 }
31263}
31264
31265#[inline]
31269#[target_feature(enable = "avx512f,avx512vl")]
31270#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31271#[cfg_attr(test, assert_instr(vpbroadcastd))]
31272#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31273pub const fn _mm_mask_set1_epi32(src: __m128i, k: __mmask8, a: i32) -> __m128i {
31274 unsafe {
31275 let r = _mm_set1_epi32(a).as_i32x4();
31276 transmute(simd_select_bitmask(k, r, src.as_i32x4()))
31277 }
31278}
31279
31280#[inline]
31284#[target_feature(enable = "avx512f,avx512vl")]
31285#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31286#[cfg_attr(test, assert_instr(vpbroadcastd))]
31287#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31288pub const fn _mm_maskz_set1_epi32(k: __mmask8, a: i32) -> __m128i {
31289 unsafe {
31290 let r = _mm_set1_epi32(a).as_i32x4();
31291 transmute(simd_select_bitmask(k, r, i32x4::ZERO))
31292 }
31293}
31294
31295#[inline]
31299#[target_feature(enable = "avx512f")]
31300#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31301#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31302pub const fn _mm512_set1_epi64(a: i64) -> __m512i {
31303 unsafe { transmute(i64x8::splat(a)) }
31304}
31305
31306#[inline]
31310#[target_feature(enable = "avx512f")]
31311#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31312#[cfg_attr(test, assert_instr(vpbroadcastq))]
31313#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31314pub const fn _mm512_mask_set1_epi64(src: __m512i, k: __mmask8, a: i64) -> __m512i {
31315 unsafe {
31316 let r = _mm512_set1_epi64(a).as_i64x8();
31317 transmute(simd_select_bitmask(k, r, src.as_i64x8()))
31318 }
31319}
31320
31321#[inline]
31325#[target_feature(enable = "avx512f")]
31326#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31327#[cfg_attr(test, assert_instr(vpbroadcastq))]
31328#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31329pub const fn _mm512_maskz_set1_epi64(k: __mmask8, a: i64) -> __m512i {
31330 unsafe {
31331 let r = _mm512_set1_epi64(a).as_i64x8();
31332 transmute(simd_select_bitmask(k, r, i64x8::ZERO))
31333 }
31334}
31335
31336#[inline]
31340#[target_feature(enable = "avx512f,avx512vl")]
31341#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31342#[cfg_attr(test, assert_instr(vpbroadcastq))]
31343#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31344pub const fn _mm256_mask_set1_epi64(src: __m256i, k: __mmask8, a: i64) -> __m256i {
31345 unsafe {
31346 let r = _mm256_set1_epi64x(a).as_i64x4();
31347 transmute(simd_select_bitmask(k, r, src.as_i64x4()))
31348 }
31349}
31350
31351#[inline]
31355#[target_feature(enable = "avx512f,avx512vl")]
31356#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31357#[cfg_attr(test, assert_instr(vpbroadcastq))]
31358#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31359pub const fn _mm256_maskz_set1_epi64(k: __mmask8, a: i64) -> __m256i {
31360 unsafe {
31361 let r = _mm256_set1_epi64x(a).as_i64x4();
31362 transmute(simd_select_bitmask(k, r, i64x4::ZERO))
31363 }
31364}
31365
31366#[inline]
31370#[target_feature(enable = "avx512f,avx512vl")]
31371#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31372#[cfg_attr(test, assert_instr(vpbroadcastq))]
31373#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31374pub const fn _mm_mask_set1_epi64(src: __m128i, k: __mmask8, a: i64) -> __m128i {
31375 unsafe {
31376 let r = _mm_set1_epi64x(a).as_i64x2();
31377 transmute(simd_select_bitmask(k, r, src.as_i64x2()))
31378 }
31379}
31380
31381#[inline]
31385#[target_feature(enable = "avx512f,avx512vl")]
31386#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31387#[cfg_attr(test, assert_instr(vpbroadcastq))]
31388#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31389pub const fn _mm_maskz_set1_epi64(k: __mmask8, a: i64) -> __m128i {
31390 unsafe {
31391 let r = _mm_set1_epi64x(a).as_i64x2();
31392 transmute(simd_select_bitmask(k, r, i64x2::ZERO))
31393 }
31394}
31395
31396#[inline]
31400#[target_feature(enable = "avx512f")]
31401#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31402#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31403pub const fn _mm512_set4_epi64(d: i64, c: i64, b: i64, a: i64) -> __m512i {
31404 _mm512_set_epi64(d, c, b, a, d, c, b, a)
31405}
31406
31407#[inline]
31411#[target_feature(enable = "avx512f")]
31412#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31413#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
31414pub const fn _mm512_setr4_epi64(d: i64, c: i64, b: i64, a: i64) -> __m512i {
31415 _mm512_set_epi64(a, b, c, d, a, b, c, d)
31416}
31417
31418#[inline]
31422#[target_feature(enable = "avx512f")]
31423#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31424#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmplt_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31426 _mm512_cmp_ps_mask::<_CMP_LT_OS>(a, b)
31427}
31428
31429#[inline]
31433#[target_feature(enable = "avx512f")]
31434#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31435#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmplt_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31437 _mm512_mask_cmp_ps_mask::<_CMP_LT_OS>(k1, a, b)
31438}
31439
31440#[inline]
31444#[target_feature(enable = "avx512f")]
31445#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31446#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpnlt_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31448 _mm512_cmp_ps_mask::<_CMP_NLT_US>(a, b)
31449}
31450
31451#[inline]
31455#[target_feature(enable = "avx512f")]
31456#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31457#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpnlt_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31459 _mm512_mask_cmp_ps_mask::<_CMP_NLT_US>(k1, a, b)
31460}
31461
31462#[inline]
31466#[target_feature(enable = "avx512f")]
31467#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31468#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmple_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31470 _mm512_cmp_ps_mask::<_CMP_LE_OS>(a, b)
31471}
31472
31473#[inline]
31477#[target_feature(enable = "avx512f")]
31478#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31479#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmple_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31481 _mm512_mask_cmp_ps_mask::<_CMP_LE_OS>(k1, a, b)
31482}
31483
31484#[inline]
31488#[target_feature(enable = "avx512f")]
31489#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31490#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpnle_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31492 _mm512_cmp_ps_mask::<_CMP_NLE_US>(a, b)
31493}
31494
31495#[inline]
31499#[target_feature(enable = "avx512f")]
31500#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31501#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpnle_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31503 _mm512_mask_cmp_ps_mask::<_CMP_NLE_US>(k1, a, b)
31504}
31505
31506#[inline]
31510#[target_feature(enable = "avx512f")]
31511#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31512#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpeq_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31514 _mm512_cmp_ps_mask::<_CMP_EQ_OQ>(a, b)
31515}
31516
31517#[inline]
31521#[target_feature(enable = "avx512f")]
31522#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31523#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpeq_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31525 _mm512_mask_cmp_ps_mask::<_CMP_EQ_OQ>(k1, a, b)
31526}
31527
31528#[inline]
31532#[target_feature(enable = "avx512f")]
31533#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31534#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpneq_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31536 _mm512_cmp_ps_mask::<_CMP_NEQ_UQ>(a, b)
31537}
31538
31539#[inline]
31543#[target_feature(enable = "avx512f")]
31544#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31545#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpneq_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31547 _mm512_mask_cmp_ps_mask::<_CMP_NEQ_UQ>(k1, a, b)
31548}
31549
31550#[inline]
31554#[target_feature(enable = "avx512f")]
31555#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31556#[rustc_legacy_const_generics(2)]
31557#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31558pub fn _mm512_cmp_ps_mask<const IMM8: i32>(a: __m512, b: __m512) -> __mmask16 {
31559 unsafe {
31560 static_assert_uimm_bits!(IMM8, 5);
31561 let neg_one = -1;
31562 let a = a.as_f32x16();
31563 let b = b.as_f32x16();
31564 let r = vcmpps(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
31565 r.cast_unsigned()
31566 }
31567}
31568
31569#[inline]
31573#[target_feature(enable = "avx512f")]
31574#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31575#[rustc_legacy_const_generics(3)]
31576#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31577pub fn _mm512_mask_cmp_ps_mask<const IMM8: i32>(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31578 unsafe {
31579 static_assert_uimm_bits!(IMM8, 5);
31580 let a = a.as_f32x16();
31581 let b = b.as_f32x16();
31582 let r = vcmpps(a, b, IMM8, k1 as i16, _MM_FROUND_CUR_DIRECTION);
31583 r.cast_unsigned()
31584 }
31585}
31586
31587#[inline]
31591#[target_feature(enable = "avx512f,avx512vl")]
31592#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31593#[rustc_legacy_const_generics(2)]
31594#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31595pub fn _mm256_cmp_ps_mask<const IMM8: i32>(a: __m256, b: __m256) -> __mmask8 {
31596 unsafe {
31597 static_assert_uimm_bits!(IMM8, 5);
31598 let neg_one = -1;
31599 let a = a.as_f32x8();
31600 let b = b.as_f32x8();
31601 let r = vcmpps256(a, b, IMM8, neg_one);
31602 r.cast_unsigned()
31603 }
31604}
31605
31606#[inline]
31610#[target_feature(enable = "avx512f,avx512vl")]
31611#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31612#[rustc_legacy_const_generics(3)]
31613#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31614pub fn _mm256_mask_cmp_ps_mask<const IMM8: i32>(k1: __mmask8, a: __m256, b: __m256) -> __mmask8 {
31615 unsafe {
31616 static_assert_uimm_bits!(IMM8, 5);
31617 let a = a.as_f32x8();
31618 let b = b.as_f32x8();
31619 let r = vcmpps256(a, b, IMM8, k1 as i8);
31620 r.cast_unsigned()
31621 }
31622}
31623
31624#[inline]
31628#[target_feature(enable = "avx512f,avx512vl")]
31629#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31630#[rustc_legacy_const_generics(2)]
31631#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31632pub fn _mm_cmp_ps_mask<const IMM8: i32>(a: __m128, b: __m128) -> __mmask8 {
31633 unsafe {
31634 static_assert_uimm_bits!(IMM8, 5);
31635 let neg_one = -1;
31636 let a = a.as_f32x4();
31637 let b = b.as_f32x4();
31638 let r = vcmpps128(a, b, IMM8, neg_one);
31639 r.cast_unsigned()
31640 }
31641}
31642
31643#[inline]
31647#[target_feature(enable = "avx512f,avx512vl")]
31648#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31649#[rustc_legacy_const_generics(3)]
31650#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31651pub fn _mm_mask_cmp_ps_mask<const IMM8: i32>(k1: __mmask8, a: __m128, b: __m128) -> __mmask8 {
31652 unsafe {
31653 static_assert_uimm_bits!(IMM8, 5);
31654 let a = a.as_f32x4();
31655 let b = b.as_f32x4();
31656 let r = vcmpps128(a, b, IMM8, k1 as i8);
31657 r.cast_unsigned()
31658 }
31659}
31660
31661#[inline]
31666#[target_feature(enable = "avx512f")]
31667#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31668#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
31669#[rustc_legacy_const_generics(2, 3)]
31670pub fn _mm512_cmp_round_ps_mask<const IMM5: i32, const SAE: i32>(
31671 a: __m512,
31672 b: __m512,
31673) -> __mmask16 {
31674 unsafe {
31675 static_assert_uimm_bits!(IMM5, 5);
31676 static_assert_mantissas_sae!(SAE);
31677 let neg_one = -1;
31678 let a = a.as_f32x16();
31679 let b = b.as_f32x16();
31680 let r = vcmpps(a, b, IMM5, neg_one, SAE);
31681 r.cast_unsigned()
31682 }
31683}
31684
31685#[inline]
31690#[target_feature(enable = "avx512f")]
31691#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31692#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
31693#[rustc_legacy_const_generics(3, 4)]
31694pub fn _mm512_mask_cmp_round_ps_mask<const IMM5: i32, const SAE: i32>(
31695 m: __mmask16,
31696 a: __m512,
31697 b: __m512,
31698) -> __mmask16 {
31699 unsafe {
31700 static_assert_uimm_bits!(IMM5, 5);
31701 static_assert_mantissas_sae!(SAE);
31702 let a = a.as_f32x16();
31703 let b = b.as_f32x16();
31704 let r = vcmpps(a, b, IMM5, m as i16, SAE);
31705 r.cast_unsigned()
31706 }
31707}
31708
31709#[inline]
31713#[target_feature(enable = "avx512f")]
31714#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31715#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpord_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31717 _mm512_cmp_ps_mask::<_CMP_ORD_Q>(a, b)
31718}
31719
31720#[inline]
31724#[target_feature(enable = "avx512f")]
31725#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31726#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpord_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31728 _mm512_mask_cmp_ps_mask::<_CMP_ORD_Q>(k1, a, b)
31729}
31730
31731#[inline]
31735#[target_feature(enable = "avx512f")]
31736#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31737#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpunord_ps_mask(a: __m512, b: __m512) -> __mmask16 {
31739 _mm512_cmp_ps_mask::<_CMP_UNORD_Q>(a, b)
31740}
31741
31742#[inline]
31746#[target_feature(enable = "avx512f")]
31747#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31748#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpunord_ps_mask(k1: __mmask16, a: __m512, b: __m512) -> __mmask16 {
31750 _mm512_mask_cmp_ps_mask::<_CMP_UNORD_Q>(k1, a, b)
31751}
31752
31753#[inline]
31757#[target_feature(enable = "avx512f")]
31758#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31759#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmplt_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
31761 _mm512_cmp_pd_mask::<_CMP_LT_OS>(a, b)
31762}
31763
31764#[inline]
31768#[target_feature(enable = "avx512f")]
31769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31770#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmplt_pd_mask(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
31772 _mm512_mask_cmp_pd_mask::<_CMP_LT_OS>(k1, a, b)
31773}
31774
31775#[inline]
31779#[target_feature(enable = "avx512f")]
31780#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31781#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpnlt_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
31783 _mm512_cmp_pd_mask::<_CMP_NLT_US>(a, b)
31784}
31785
31786#[inline]
31790#[target_feature(enable = "avx512f")]
31791#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31792#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpnlt_pd_mask(m: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
31794 _mm512_mask_cmp_pd_mask::<_CMP_NLT_US>(m, a, b)
31795}
31796
31797#[inline]
31801#[target_feature(enable = "avx512f")]
31802#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31803#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmple_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
31805 _mm512_cmp_pd_mask::<_CMP_LE_OS>(a, b)
31806}
31807
31808#[inline]
31812#[target_feature(enable = "avx512f")]
31813#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31814#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmple_pd_mask(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
31816 _mm512_mask_cmp_pd_mask::<_CMP_LE_OS>(k1, a, b)
31817}
31818
31819#[inline]
31823#[target_feature(enable = "avx512f")]
31824#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31825#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpnle_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
31827 _mm512_cmp_pd_mask::<_CMP_NLE_US>(a, b)
31828}
31829
31830#[inline]
31834#[target_feature(enable = "avx512f")]
31835#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31836#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpnle_pd_mask(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
31838 _mm512_mask_cmp_pd_mask::<_CMP_NLE_US>(k1, a, b)
31839}
31840
31841#[inline]
31845#[target_feature(enable = "avx512f")]
31846#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31847#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpeq_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
31849 _mm512_cmp_pd_mask::<_CMP_EQ_OQ>(a, b)
31850}
31851
31852#[inline]
31856#[target_feature(enable = "avx512f")]
31857#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31858#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpeq_pd_mask(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
31860 _mm512_mask_cmp_pd_mask::<_CMP_EQ_OQ>(k1, a, b)
31861}
31862
31863#[inline]
31867#[target_feature(enable = "avx512f")]
31868#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31869#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpneq_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
31871 _mm512_cmp_pd_mask::<_CMP_NEQ_UQ>(a, b)
31872}
31873
31874#[inline]
31878#[target_feature(enable = "avx512f")]
31879#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31880#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpneq_pd_mask(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
31882 _mm512_mask_cmp_pd_mask::<_CMP_NEQ_UQ>(k1, a, b)
31883}
31884
31885#[inline]
31889#[target_feature(enable = "avx512f")]
31890#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31891#[rustc_legacy_const_generics(2)]
31892#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31893pub fn _mm512_cmp_pd_mask<const IMM8: i32>(a: __m512d, b: __m512d) -> __mmask8 {
31894 unsafe {
31895 static_assert_uimm_bits!(IMM8, 5);
31896 let neg_one = -1;
31897 let a = a.as_f64x8();
31898 let b = b.as_f64x8();
31899 let r = vcmppd(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
31900 r.cast_unsigned()
31901 }
31902}
31903
31904#[inline]
31908#[target_feature(enable = "avx512f")]
31909#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31910#[rustc_legacy_const_generics(3)]
31911#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31912pub fn _mm512_mask_cmp_pd_mask<const IMM8: i32>(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
31913 unsafe {
31914 static_assert_uimm_bits!(IMM8, 5);
31915 let a = a.as_f64x8();
31916 let b = b.as_f64x8();
31917 let r = vcmppd(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
31918 r.cast_unsigned()
31919 }
31920}
31921
31922#[inline]
31926#[target_feature(enable = "avx512f,avx512vl")]
31927#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31928#[rustc_legacy_const_generics(2)]
31929#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31930pub fn _mm256_cmp_pd_mask<const IMM8: i32>(a: __m256d, b: __m256d) -> __mmask8 {
31931 unsafe {
31932 static_assert_uimm_bits!(IMM8, 5);
31933 let neg_one = -1;
31934 let a = a.as_f64x4();
31935 let b = b.as_f64x4();
31936 let r = vcmppd256(a, b, IMM8, neg_one);
31937 r.cast_unsigned()
31938 }
31939}
31940
31941#[inline]
31945#[target_feature(enable = "avx512f,avx512vl")]
31946#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31947#[rustc_legacy_const_generics(3)]
31948#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31949pub fn _mm256_mask_cmp_pd_mask<const IMM8: i32>(k1: __mmask8, a: __m256d, b: __m256d) -> __mmask8 {
31950 unsafe {
31951 static_assert_uimm_bits!(IMM8, 5);
31952 let a = a.as_f64x4();
31953 let b = b.as_f64x4();
31954 let r = vcmppd256(a, b, IMM8, k1 as i8);
31955 r.cast_unsigned()
31956 }
31957}
31958
31959#[inline]
31963#[target_feature(enable = "avx512f,avx512vl")]
31964#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31965#[rustc_legacy_const_generics(2)]
31966#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31967pub fn _mm_cmp_pd_mask<const IMM8: i32>(a: __m128d, b: __m128d) -> __mmask8 {
31968 unsafe {
31969 static_assert_uimm_bits!(IMM8, 5);
31970 let neg_one = -1;
31971 let a = a.as_f64x2();
31972 let b = b.as_f64x2();
31973 let r = vcmppd128(a, b, IMM8, neg_one);
31974 r.cast_unsigned()
31975 }
31976}
31977
31978#[inline]
31982#[target_feature(enable = "avx512f,avx512vl")]
31983#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
31984#[rustc_legacy_const_generics(3)]
31985#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
31986pub fn _mm_mask_cmp_pd_mask<const IMM8: i32>(k1: __mmask8, a: __m128d, b: __m128d) -> __mmask8 {
31987 unsafe {
31988 static_assert_uimm_bits!(IMM8, 5);
31989 let a = a.as_f64x2();
31990 let b = b.as_f64x2();
31991 let r = vcmppd128(a, b, IMM8, k1 as i8);
31992 r.cast_unsigned()
31993 }
31994}
31995
31996#[inline]
32001#[target_feature(enable = "avx512f")]
32002#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32003#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
32004#[rustc_legacy_const_generics(2, 3)]
32005pub fn _mm512_cmp_round_pd_mask<const IMM5: i32, const SAE: i32>(
32006 a: __m512d,
32007 b: __m512d,
32008) -> __mmask8 {
32009 unsafe {
32010 static_assert_uimm_bits!(IMM5, 5);
32011 static_assert_mantissas_sae!(SAE);
32012 let neg_one = -1;
32013 let a = a.as_f64x8();
32014 let b = b.as_f64x8();
32015 let r = vcmppd(a, b, IMM5, neg_one, SAE);
32016 r.cast_unsigned()
32017 }
32018}
32019
32020#[inline]
32025#[target_feature(enable = "avx512f")]
32026#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32027#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
32028#[rustc_legacy_const_generics(3, 4)]
32029pub fn _mm512_mask_cmp_round_pd_mask<const IMM5: i32, const SAE: i32>(
32030 k1: __mmask8,
32031 a: __m512d,
32032 b: __m512d,
32033) -> __mmask8 {
32034 unsafe {
32035 static_assert_uimm_bits!(IMM5, 5);
32036 static_assert_mantissas_sae!(SAE);
32037 let a = a.as_f64x8();
32038 let b = b.as_f64x8();
32039 let r = vcmppd(a, b, IMM5, k1 as i8, SAE);
32040 r.cast_unsigned()
32041 }
32042}
32043
32044#[inline]
32048#[target_feature(enable = "avx512f")]
32049#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32050#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpord_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
32052 _mm512_cmp_pd_mask::<_CMP_ORD_Q>(a, b)
32053}
32054
32055#[inline]
32059#[target_feature(enable = "avx512f")]
32060#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32061#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpord_pd_mask(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
32063 _mm512_mask_cmp_pd_mask::<_CMP_ORD_Q>(k1, a, b)
32064}
32065
32066#[inline]
32070#[target_feature(enable = "avx512f")]
32071#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32072#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_cmpunord_pd_mask(a: __m512d, b: __m512d) -> __mmask8 {
32074 _mm512_cmp_pd_mask::<_CMP_UNORD_Q>(a, b)
32075}
32076
32077#[inline]
32081#[target_feature(enable = "avx512f")]
32082#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32083#[cfg_attr(test, assert_instr(vcmp))] pub fn _mm512_mask_cmpunord_pd_mask(k1: __mmask8, a: __m512d, b: __m512d) -> __mmask8 {
32085 _mm512_mask_cmp_pd_mask::<_CMP_UNORD_Q>(k1, a, b)
32086}
32087
32088#[inline]
32092#[target_feature(enable = "avx512f")]
32093#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32094#[rustc_legacy_const_generics(2)]
32095#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
32096pub fn _mm_cmp_ss_mask<const IMM8: i32>(a: __m128, b: __m128) -> __mmask8 {
32097 unsafe {
32098 static_assert_uimm_bits!(IMM8, 5);
32099 let neg_one = -1;
32100 let r = vcmpss(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
32101 r.cast_unsigned()
32102 }
32103}
32104
32105#[inline]
32109#[target_feature(enable = "avx512f")]
32110#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32111#[rustc_legacy_const_generics(3)]
32112#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
32113pub fn _mm_mask_cmp_ss_mask<const IMM8: i32>(k1: __mmask8, a: __m128, b: __m128) -> __mmask8 {
32114 unsafe {
32115 static_assert_uimm_bits!(IMM8, 5);
32116 let r = vcmpss(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
32117 r.cast_unsigned()
32118 }
32119}
32120
32121#[inline]
32126#[target_feature(enable = "avx512f")]
32127#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32128#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
32129#[rustc_legacy_const_generics(2, 3)]
32130pub fn _mm_cmp_round_ss_mask<const IMM5: i32, const SAE: i32>(a: __m128, b: __m128) -> __mmask8 {
32131 unsafe {
32132 static_assert_uimm_bits!(IMM5, 5);
32133 static_assert_mantissas_sae!(SAE);
32134 let neg_one = -1;
32135 let r = vcmpss(a, b, IMM5, neg_one, SAE);
32136 r.cast_unsigned()
32137 }
32138}
32139
32140#[inline]
32145#[target_feature(enable = "avx512f")]
32146#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32147#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
32148#[rustc_legacy_const_generics(3, 4)]
32149pub fn _mm_mask_cmp_round_ss_mask<const IMM5: i32, const SAE: i32>(
32150 k1: __mmask8,
32151 a: __m128,
32152 b: __m128,
32153) -> __mmask8 {
32154 unsafe {
32155 static_assert_uimm_bits!(IMM5, 5);
32156 static_assert_mantissas_sae!(SAE);
32157 let r = vcmpss(a, b, IMM5, k1 as i8, SAE);
32158 r.cast_unsigned()
32159 }
32160}
32161
32162#[inline]
32166#[target_feature(enable = "avx512f")]
32167#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32168#[rustc_legacy_const_generics(2)]
32169#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
32170pub fn _mm_cmp_sd_mask<const IMM8: i32>(a: __m128d, b: __m128d) -> __mmask8 {
32171 unsafe {
32172 static_assert_uimm_bits!(IMM8, 5);
32173 let neg_one = -1;
32174 let r = vcmpsd(a, b, IMM8, neg_one, _MM_FROUND_CUR_DIRECTION);
32175 r.cast_unsigned()
32176 }
32177}
32178
32179#[inline]
32183#[target_feature(enable = "avx512f")]
32184#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32185#[rustc_legacy_const_generics(3)]
32186#[cfg_attr(test, assert_instr(vcmp, IMM8 = 0))]
32187pub fn _mm_mask_cmp_sd_mask<const IMM8: i32>(k1: __mmask8, a: __m128d, b: __m128d) -> __mmask8 {
32188 unsafe {
32189 static_assert_uimm_bits!(IMM8, 5);
32190 let r = vcmpsd(a, b, IMM8, k1 as i8, _MM_FROUND_CUR_DIRECTION);
32191 r.cast_unsigned()
32192 }
32193}
32194
32195#[inline]
32200#[target_feature(enable = "avx512f")]
32201#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32202#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
32203#[rustc_legacy_const_generics(2, 3)]
32204pub fn _mm_cmp_round_sd_mask<const IMM5: i32, const SAE: i32>(a: __m128d, b: __m128d) -> __mmask8 {
32205 unsafe {
32206 static_assert_uimm_bits!(IMM5, 5);
32207 static_assert_mantissas_sae!(SAE);
32208 let neg_one = -1;
32209 let r = vcmpsd(a, b, IMM5, neg_one, SAE);
32210 r.cast_unsigned()
32211 }
32212}
32213
32214#[inline]
32219#[target_feature(enable = "avx512f")]
32220#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32221#[cfg_attr(test, assert_instr(vcmp, IMM5 = 0, SAE = 4))]
32222#[rustc_legacy_const_generics(3, 4)]
32223pub fn _mm_mask_cmp_round_sd_mask<const IMM5: i32, const SAE: i32>(
32224 k1: __mmask8,
32225 a: __m128d,
32226 b: __m128d,
32227) -> __mmask8 {
32228 unsafe {
32229 static_assert_uimm_bits!(IMM5, 5);
32230 static_assert_mantissas_sae!(SAE);
32231 let r = vcmpsd(a, b, IMM5, k1 as i8, SAE);
32232 r.cast_unsigned()
32233 }
32234}
32235
32236#[inline]
32240#[target_feature(enable = "avx512f")]
32241#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32242#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32244pub const fn _mm512_cmplt_epu32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32245 unsafe { simd_bitmask::<u32x16, _>(simd_lt(a.as_u32x16(), b.as_u32x16())) }
32246}
32247
32248#[inline]
32252#[target_feature(enable = "avx512f")]
32253#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32254#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32256pub const fn _mm512_mask_cmplt_epu32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32257 _mm512_mask_cmp_epu32_mask::<_MM_CMPINT_LT>(k1, a, b)
32258}
32259
32260#[inline]
32264#[target_feature(enable = "avx512f,avx512vl")]
32265#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32266#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32268pub const fn _mm256_cmplt_epu32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32269 unsafe { simd_bitmask::<u32x8, _>(simd_lt(a.as_u32x8(), b.as_u32x8())) }
32270}
32271
32272#[inline]
32276#[target_feature(enable = "avx512f,avx512vl")]
32277#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32278#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32280pub const fn _mm256_mask_cmplt_epu32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32281 _mm256_mask_cmp_epu32_mask::<_MM_CMPINT_LT>(k1, a, b)
32282}
32283
32284#[inline]
32288#[target_feature(enable = "avx512f,avx512vl")]
32289#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32290#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32292pub const fn _mm_cmplt_epu32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32293 unsafe { simd_bitmask::<u32x4, _>(simd_lt(a.as_u32x4(), b.as_u32x4())) }
32294}
32295
32296#[inline]
32300#[target_feature(enable = "avx512f,avx512vl")]
32301#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32302#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32304pub const fn _mm_mask_cmplt_epu32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32305 _mm_mask_cmp_epu32_mask::<_MM_CMPINT_LT>(k1, a, b)
32306}
32307
32308#[inline]
32312#[target_feature(enable = "avx512f")]
32313#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32314#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32316pub const fn _mm512_cmpgt_epu32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32317 unsafe { simd_bitmask::<u32x16, _>(simd_gt(a.as_u32x16(), b.as_u32x16())) }
32318}
32319
32320#[inline]
32324#[target_feature(enable = "avx512f")]
32325#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32326#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32328pub const fn _mm512_mask_cmpgt_epu32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32329 _mm512_mask_cmp_epu32_mask::<_MM_CMPINT_NLE>(k1, a, b)
32330}
32331
32332#[inline]
32336#[target_feature(enable = "avx512f,avx512vl")]
32337#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32338#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32340pub const fn _mm256_cmpgt_epu32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32341 unsafe { simd_bitmask::<u32x8, _>(simd_gt(a.as_u32x8(), b.as_u32x8())) }
32342}
32343
32344#[inline]
32348#[target_feature(enable = "avx512f,avx512vl")]
32349#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32350#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32352pub const fn _mm256_mask_cmpgt_epu32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32353 _mm256_mask_cmp_epu32_mask::<_MM_CMPINT_NLE>(k1, a, b)
32354}
32355
32356#[inline]
32360#[target_feature(enable = "avx512f,avx512vl")]
32361#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32362#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32364pub const fn _mm_cmpgt_epu32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32365 unsafe { simd_bitmask::<u32x4, _>(simd_gt(a.as_u32x4(), b.as_u32x4())) }
32366}
32367
32368#[inline]
32372#[target_feature(enable = "avx512f,avx512vl")]
32373#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32374#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32376pub const fn _mm_mask_cmpgt_epu32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32377 _mm_mask_cmp_epu32_mask::<_MM_CMPINT_NLE>(k1, a, b)
32378}
32379
32380#[inline]
32384#[target_feature(enable = "avx512f")]
32385#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32386#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32388pub const fn _mm512_cmple_epu32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32389 unsafe { simd_bitmask::<u32x16, _>(simd_le(a.as_u32x16(), b.as_u32x16())) }
32390}
32391
32392#[inline]
32396#[target_feature(enable = "avx512f")]
32397#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32398#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32400pub const fn _mm512_mask_cmple_epu32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32401 _mm512_mask_cmp_epu32_mask::<_MM_CMPINT_LE>(k1, a, b)
32402}
32403
32404#[inline]
32408#[target_feature(enable = "avx512f,avx512vl")]
32409#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32410#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32412pub const fn _mm256_cmple_epu32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32413 unsafe { simd_bitmask::<u32x8, _>(simd_le(a.as_u32x8(), b.as_u32x8())) }
32414}
32415
32416#[inline]
32420#[target_feature(enable = "avx512f,avx512vl")]
32421#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32422#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32424pub const fn _mm256_mask_cmple_epu32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32425 _mm256_mask_cmp_epu32_mask::<_MM_CMPINT_LE>(k1, a, b)
32426}
32427
32428#[inline]
32432#[target_feature(enable = "avx512f,avx512vl")]
32433#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32434#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32436pub const fn _mm_cmple_epu32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32437 unsafe { simd_bitmask::<u32x4, _>(simd_le(a.as_u32x4(), b.as_u32x4())) }
32438}
32439
32440#[inline]
32444#[target_feature(enable = "avx512f,avx512vl")]
32445#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32446#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32448pub const fn _mm_mask_cmple_epu32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32449 _mm_mask_cmp_epu32_mask::<_MM_CMPINT_LE>(k1, a, b)
32450}
32451
32452#[inline]
32456#[target_feature(enable = "avx512f")]
32457#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32458#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32460pub const fn _mm512_cmpge_epu32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32461 unsafe { simd_bitmask::<u32x16, _>(simd_ge(a.as_u32x16(), b.as_u32x16())) }
32462}
32463
32464#[inline]
32468#[target_feature(enable = "avx512f")]
32469#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32470#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32472pub const fn _mm512_mask_cmpge_epu32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32473 _mm512_mask_cmp_epu32_mask::<_MM_CMPINT_NLT>(k1, a, b)
32474}
32475
32476#[inline]
32480#[target_feature(enable = "avx512f,avx512vl")]
32481#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32482#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32484pub const fn _mm256_cmpge_epu32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32485 unsafe { simd_bitmask::<u32x8, _>(simd_ge(a.as_u32x8(), b.as_u32x8())) }
32486}
32487
32488#[inline]
32492#[target_feature(enable = "avx512f,avx512vl")]
32493#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32494#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32496pub const fn _mm256_mask_cmpge_epu32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32497 _mm256_mask_cmp_epu32_mask::<_MM_CMPINT_NLT>(k1, a, b)
32498}
32499
32500#[inline]
32504#[target_feature(enable = "avx512f,avx512vl")]
32505#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32506#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32508pub const fn _mm_cmpge_epu32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32509 unsafe { simd_bitmask::<u32x4, _>(simd_ge(a.as_u32x4(), b.as_u32x4())) }
32510}
32511
32512#[inline]
32516#[target_feature(enable = "avx512f,avx512vl")]
32517#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32518#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32520pub const fn _mm_mask_cmpge_epu32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32521 _mm_mask_cmp_epu32_mask::<_MM_CMPINT_NLT>(k1, a, b)
32522}
32523
32524#[inline]
32528#[target_feature(enable = "avx512f")]
32529#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32530#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32532pub const fn _mm512_cmpeq_epu32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32533 unsafe { simd_bitmask::<u32x16, _>(simd_eq(a.as_u32x16(), b.as_u32x16())) }
32534}
32535
32536#[inline]
32540#[target_feature(enable = "avx512f")]
32541#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32542#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32544pub const fn _mm512_mask_cmpeq_epu32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32545 _mm512_mask_cmp_epu32_mask::<_MM_CMPINT_EQ>(k1, a, b)
32546}
32547
32548#[inline]
32552#[target_feature(enable = "avx512f,avx512vl")]
32553#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32554#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32556pub const fn _mm256_cmpeq_epu32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32557 unsafe { simd_bitmask::<u32x8, _>(simd_eq(a.as_u32x8(), b.as_u32x8())) }
32558}
32559
32560#[inline]
32564#[target_feature(enable = "avx512f,avx512vl")]
32565#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32566#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32568pub const fn _mm256_mask_cmpeq_epu32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32569 _mm256_mask_cmp_epu32_mask::<_MM_CMPINT_EQ>(k1, a, b)
32570}
32571
32572#[inline]
32576#[target_feature(enable = "avx512f,avx512vl")]
32577#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32578#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32580pub const fn _mm_cmpeq_epu32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32581 unsafe { simd_bitmask::<u32x4, _>(simd_eq(a.as_u32x4(), b.as_u32x4())) }
32582}
32583
32584#[inline]
32588#[target_feature(enable = "avx512f,avx512vl")]
32589#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32590#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32592pub const fn _mm_mask_cmpeq_epu32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32593 _mm_mask_cmp_epu32_mask::<_MM_CMPINT_EQ>(k1, a, b)
32594}
32595
32596#[inline]
32600#[target_feature(enable = "avx512f")]
32601#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32602#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32604pub const fn _mm512_cmpneq_epu32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32605 unsafe { simd_bitmask::<u32x16, _>(simd_ne(a.as_u32x16(), b.as_u32x16())) }
32606}
32607
32608#[inline]
32612#[target_feature(enable = "avx512f")]
32613#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32614#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32616pub const fn _mm512_mask_cmpneq_epu32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32617 _mm512_mask_cmp_epu32_mask::<_MM_CMPINT_NE>(k1, a, b)
32618}
32619
32620#[inline]
32624#[target_feature(enable = "avx512f,avx512vl")]
32625#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32626#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32628pub const fn _mm256_cmpneq_epu32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32629 unsafe { simd_bitmask::<u32x8, _>(simd_ne(a.as_u32x8(), b.as_u32x8())) }
32630}
32631
32632#[inline]
32636#[target_feature(enable = "avx512f,avx512vl")]
32637#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32638#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32640pub const fn _mm256_mask_cmpneq_epu32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32641 _mm256_mask_cmp_epu32_mask::<_MM_CMPINT_NE>(k1, a, b)
32642}
32643
32644#[inline]
32648#[target_feature(enable = "avx512f,avx512vl")]
32649#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32650#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32652pub const fn _mm_cmpneq_epu32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32653 unsafe { simd_bitmask::<u32x4, _>(simd_ne(a.as_u32x4(), b.as_u32x4())) }
32654}
32655
32656#[inline]
32660#[target_feature(enable = "avx512f,avx512vl")]
32661#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32662#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32664pub const fn _mm_mask_cmpneq_epu32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32665 _mm_mask_cmp_epu32_mask::<_MM_CMPINT_NE>(k1, a, b)
32666}
32667
32668#[inline]
32672#[target_feature(enable = "avx512f")]
32673#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32674#[rustc_legacy_const_generics(2)]
32675#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
32676#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32677pub const fn _mm512_cmp_epu32_mask<const IMM3: _MM_CMPINT_ENUM>(
32678 a: __m512i,
32679 b: __m512i,
32680) -> __mmask16 {
32681 unsafe {
32682 static_assert_uimm_bits!(IMM3, 3);
32683 let a = a.as_u32x16();
32684 let b = b.as_u32x16();
32685 let r = match IMM3 {
32686 0 => simd_eq(a, b),
32687 1 => simd_lt(a, b),
32688 2 => simd_le(a, b),
32689 3 => i32x16::ZERO,
32690 4 => simd_ne(a, b),
32691 5 => simd_ge(a, b),
32692 6 => simd_gt(a, b),
32693 _ => i32x16::splat(-1),
32694 };
32695 simd_bitmask(r)
32696 }
32697}
32698
32699#[inline]
32703#[target_feature(enable = "avx512f")]
32704#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32705#[rustc_legacy_const_generics(3)]
32706#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
32707#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32708pub const fn _mm512_mask_cmp_epu32_mask<const IMM3: _MM_CMPINT_ENUM>(
32709 k1: __mmask16,
32710 a: __m512i,
32711 b: __m512i,
32712) -> __mmask16 {
32713 unsafe {
32714 static_assert_uimm_bits!(IMM3, 3);
32715 let a = a.as_u32x16();
32716 let b = b.as_u32x16();
32717 let k1 = simd_select_bitmask(k1, i32x16::splat(-1), i32x16::ZERO);
32718 let r = match IMM3 {
32719 0 => simd_and(k1, simd_eq(a, b)),
32720 1 => simd_and(k1, simd_lt(a, b)),
32721 2 => simd_and(k1, simd_le(a, b)),
32722 3 => i32x16::ZERO,
32723 4 => simd_and(k1, simd_ne(a, b)),
32724 5 => simd_and(k1, simd_ge(a, b)),
32725 6 => simd_and(k1, simd_gt(a, b)),
32726 _ => k1,
32727 };
32728 simd_bitmask(r)
32729 }
32730}
32731
32732#[inline]
32736#[target_feature(enable = "avx512f,avx512vl")]
32737#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32738#[rustc_legacy_const_generics(2)]
32739#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
32740#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32741pub const fn _mm256_cmp_epu32_mask<const IMM3: _MM_CMPINT_ENUM>(
32742 a: __m256i,
32743 b: __m256i,
32744) -> __mmask8 {
32745 unsafe {
32746 static_assert_uimm_bits!(IMM3, 3);
32747 let a = a.as_u32x8();
32748 let b = b.as_u32x8();
32749 let r = match IMM3 {
32750 0 => simd_eq(a, b),
32751 1 => simd_lt(a, b),
32752 2 => simd_le(a, b),
32753 3 => i32x8::ZERO,
32754 4 => simd_ne(a, b),
32755 5 => simd_ge(a, b),
32756 6 => simd_gt(a, b),
32757 _ => i32x8::splat(-1),
32758 };
32759 simd_bitmask(r)
32760 }
32761}
32762
32763#[inline]
32767#[target_feature(enable = "avx512f,avx512vl")]
32768#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32769#[rustc_legacy_const_generics(3)]
32770#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
32771#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32772pub const fn _mm256_mask_cmp_epu32_mask<const IMM3: _MM_CMPINT_ENUM>(
32773 k1: __mmask8,
32774 a: __m256i,
32775 b: __m256i,
32776) -> __mmask8 {
32777 unsafe {
32778 static_assert_uimm_bits!(IMM3, 3);
32779 let a = a.as_u32x8();
32780 let b = b.as_u32x8();
32781 let k1 = simd_select_bitmask(k1, i32x8::splat(-1), i32x8::ZERO);
32782 let r = match IMM3 {
32783 0 => simd_and(k1, simd_eq(a, b)),
32784 1 => simd_and(k1, simd_lt(a, b)),
32785 2 => simd_and(k1, simd_le(a, b)),
32786 3 => i32x8::ZERO,
32787 4 => simd_and(k1, simd_ne(a, b)),
32788 5 => simd_and(k1, simd_ge(a, b)),
32789 6 => simd_and(k1, simd_gt(a, b)),
32790 _ => k1,
32791 };
32792 simd_bitmask(r)
32793 }
32794}
32795
32796#[inline]
32800#[target_feature(enable = "avx512f,avx512vl")]
32801#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32802#[rustc_legacy_const_generics(2)]
32803#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
32804#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32805pub const fn _mm_cmp_epu32_mask<const IMM3: _MM_CMPINT_ENUM>(a: __m128i, b: __m128i) -> __mmask8 {
32806 unsafe {
32807 static_assert_uimm_bits!(IMM3, 3);
32808 let a = a.as_u32x4();
32809 let b = b.as_u32x4();
32810 let r = match IMM3 {
32811 0 => simd_eq(a, b),
32812 1 => simd_lt(a, b),
32813 2 => simd_le(a, b),
32814 3 => i32x4::ZERO,
32815 4 => simd_ne(a, b),
32816 5 => simd_ge(a, b),
32817 6 => simd_gt(a, b),
32818 _ => i32x4::splat(-1),
32819 };
32820 simd_bitmask(r)
32821 }
32822}
32823
32824#[inline]
32828#[target_feature(enable = "avx512f,avx512vl")]
32829#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32830#[rustc_legacy_const_generics(3)]
32831#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
32832#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32833pub const fn _mm_mask_cmp_epu32_mask<const IMM3: _MM_CMPINT_ENUM>(
32834 k1: __mmask8,
32835 a: __m128i,
32836 b: __m128i,
32837) -> __mmask8 {
32838 unsafe {
32839 static_assert_uimm_bits!(IMM3, 3);
32840 let a = a.as_u32x4();
32841 let b = b.as_u32x4();
32842 let k1 = simd_select_bitmask(k1, i32x4::splat(-1), i32x4::ZERO);
32843 let r = match IMM3 {
32844 0 => simd_and(k1, simd_eq(a, b)),
32845 1 => simd_and(k1, simd_lt(a, b)),
32846 2 => simd_and(k1, simd_le(a, b)),
32847 3 => i32x4::ZERO,
32848 4 => simd_and(k1, simd_ne(a, b)),
32849 5 => simd_and(k1, simd_ge(a, b)),
32850 6 => simd_and(k1, simd_gt(a, b)),
32851 _ => k1,
32852 };
32853 simd_bitmask(r)
32854 }
32855}
32856
32857#[inline]
32861#[target_feature(enable = "avx512f")]
32862#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32863#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32865pub const fn _mm512_cmplt_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32866 unsafe { simd_bitmask::<i32x16, _>(simd_lt(a.as_i32x16(), b.as_i32x16())) }
32867}
32868
32869#[inline]
32873#[target_feature(enable = "avx512f")]
32874#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32875#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32877pub const fn _mm512_mask_cmplt_epi32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32878 _mm512_mask_cmp_epi32_mask::<_MM_CMPINT_LT>(k1, a, b)
32879}
32880
32881#[inline]
32885#[target_feature(enable = "avx512f,avx512vl")]
32886#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32887#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32889pub const fn _mm256_cmplt_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32890 unsafe { simd_bitmask::<i32x8, _>(simd_lt(a.as_i32x8(), b.as_i32x8())) }
32891}
32892
32893#[inline]
32897#[target_feature(enable = "avx512f,avx512vl")]
32898#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32899#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32901pub const fn _mm256_mask_cmplt_epi32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32902 _mm256_mask_cmp_epi32_mask::<_MM_CMPINT_LT>(k1, a, b)
32903}
32904
32905#[inline]
32909#[target_feature(enable = "avx512f,avx512vl")]
32910#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32911#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32913pub const fn _mm_cmplt_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32914 unsafe { simd_bitmask::<i32x4, _>(simd_lt(a.as_i32x4(), b.as_i32x4())) }
32915}
32916
32917#[inline]
32921#[target_feature(enable = "avx512f,avx512vl")]
32922#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32923#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32925pub const fn _mm_mask_cmplt_epi32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32926 _mm_mask_cmp_epi32_mask::<_MM_CMPINT_LT>(k1, a, b)
32927}
32928
32929#[inline]
32933#[target_feature(enable = "avx512f")]
32934#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32935#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32937pub const fn _mm512_cmpgt_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
32938 unsafe { simd_bitmask::<i32x16, _>(simd_gt(a.as_i32x16(), b.as_i32x16())) }
32939}
32940
32941#[inline]
32945#[target_feature(enable = "avx512f")]
32946#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32947#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32949pub const fn _mm512_mask_cmpgt_epi32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
32950 _mm512_mask_cmp_epi32_mask::<_MM_CMPINT_NLE>(k1, a, b)
32951}
32952
32953#[inline]
32957#[target_feature(enable = "avx512f,avx512vl")]
32958#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32959#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32961pub const fn _mm256_cmpgt_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
32962 unsafe { simd_bitmask::<i32x8, _>(simd_gt(a.as_i32x8(), b.as_i32x8())) }
32963}
32964
32965#[inline]
32969#[target_feature(enable = "avx512f,avx512vl")]
32970#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32971#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32973pub const fn _mm256_mask_cmpgt_epi32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
32974 _mm256_mask_cmp_epi32_mask::<_MM_CMPINT_NLE>(k1, a, b)
32975}
32976
32977#[inline]
32981#[target_feature(enable = "avx512f,avx512vl")]
32982#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32983#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32985pub const fn _mm_cmpgt_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
32986 unsafe { simd_bitmask::<i32x4, _>(simd_gt(a.as_i32x4(), b.as_i32x4())) }
32987}
32988
32989#[inline]
32993#[target_feature(enable = "avx512f,avx512vl")]
32994#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
32995#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
32997pub const fn _mm_mask_cmpgt_epi32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
32998 _mm_mask_cmp_epi32_mask::<_MM_CMPINT_NLE>(k1, a, b)
32999}
33000
33001#[inline]
33005#[target_feature(enable = "avx512f")]
33006#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33007#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33009pub const fn _mm512_cmple_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
33010 unsafe { simd_bitmask::<i32x16, _>(simd_le(a.as_i32x16(), b.as_i32x16())) }
33011}
33012
33013#[inline]
33017#[target_feature(enable = "avx512f")]
33018#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33019#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33021pub const fn _mm512_mask_cmple_epi32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
33022 _mm512_mask_cmp_epi32_mask::<_MM_CMPINT_LE>(k1, a, b)
33023}
33024
33025#[inline]
33029#[target_feature(enable = "avx512f,avx512vl")]
33030#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33031#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33033pub const fn _mm256_cmple_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
33034 unsafe { simd_bitmask::<i32x8, _>(simd_le(a.as_i32x8(), b.as_i32x8())) }
33035}
33036
33037#[inline]
33041#[target_feature(enable = "avx512f,avx512vl")]
33042#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33043#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33045pub const fn _mm256_mask_cmple_epi32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33046 _mm256_mask_cmp_epi32_mask::<_MM_CMPINT_LE>(k1, a, b)
33047}
33048
33049#[inline]
33053#[target_feature(enable = "avx512f,avx512vl")]
33054#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33055#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33057pub const fn _mm_cmple_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
33058 unsafe { simd_bitmask::<i32x4, _>(simd_le(a.as_i32x4(), b.as_i32x4())) }
33059}
33060
33061#[inline]
33065#[target_feature(enable = "avx512f,avx512vl")]
33066#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33067#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33069pub const fn _mm_mask_cmple_epi32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33070 _mm_mask_cmp_epi32_mask::<_MM_CMPINT_LE>(k1, a, b)
33071}
33072
33073#[inline]
33077#[target_feature(enable = "avx512f")]
33078#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33079#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33081pub const fn _mm512_cmpge_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
33082 unsafe { simd_bitmask::<i32x16, _>(simd_ge(a.as_i32x16(), b.as_i32x16())) }
33083}
33084
33085#[inline]
33089#[target_feature(enable = "avx512f")]
33090#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33091#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33093pub const fn _mm512_mask_cmpge_epi32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
33094 _mm512_mask_cmp_epi32_mask::<_MM_CMPINT_NLT>(k1, a, b)
33095}
33096
33097#[inline]
33101#[target_feature(enable = "avx512f,avx512vl")]
33102#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33103#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33105pub const fn _mm256_cmpge_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
33106 unsafe { simd_bitmask::<i32x8, _>(simd_ge(a.as_i32x8(), b.as_i32x8())) }
33107}
33108
33109#[inline]
33113#[target_feature(enable = "avx512f,avx512vl")]
33114#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33115#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33117pub const fn _mm256_mask_cmpge_epi32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33118 _mm256_mask_cmp_epi32_mask::<_MM_CMPINT_NLT>(k1, a, b)
33119}
33120
33121#[inline]
33125#[target_feature(enable = "avx512f,avx512vl")]
33126#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33127#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33129pub const fn _mm_cmpge_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
33130 unsafe { simd_bitmask::<i32x4, _>(simd_ge(a.as_i32x4(), b.as_i32x4())) }
33131}
33132
33133#[inline]
33137#[target_feature(enable = "avx512f,avx512vl")]
33138#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33139#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33141pub const fn _mm_mask_cmpge_epi32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33142 _mm_mask_cmp_epi32_mask::<_MM_CMPINT_NLT>(k1, a, b)
33143}
33144
33145#[inline]
33149#[target_feature(enable = "avx512f")]
33150#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33151#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33153pub const fn _mm512_cmpeq_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
33154 unsafe { simd_bitmask::<i32x16, _>(simd_eq(a.as_i32x16(), b.as_i32x16())) }
33155}
33156
33157#[inline]
33161#[target_feature(enable = "avx512f")]
33162#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33163#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33165pub const fn _mm512_mask_cmpeq_epi32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
33166 _mm512_mask_cmp_epi32_mask::<_MM_CMPINT_EQ>(k1, a, b)
33167}
33168
33169#[inline]
33173#[target_feature(enable = "avx512f,avx512vl")]
33174#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33175#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33177pub const fn _mm256_cmpeq_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
33178 unsafe { simd_bitmask::<i32x8, _>(simd_eq(a.as_i32x8(), b.as_i32x8())) }
33179}
33180
33181#[inline]
33185#[target_feature(enable = "avx512f,avx512vl")]
33186#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33187#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33189pub const fn _mm256_mask_cmpeq_epi32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33190 _mm256_mask_cmp_epi32_mask::<_MM_CMPINT_EQ>(k1, a, b)
33191}
33192
33193#[inline]
33197#[target_feature(enable = "avx512f,avx512vl")]
33198#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33199#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33201pub const fn _mm_cmpeq_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
33202 unsafe { simd_bitmask::<i32x4, _>(simd_eq(a.as_i32x4(), b.as_i32x4())) }
33203}
33204
33205#[inline]
33209#[target_feature(enable = "avx512f,avx512vl")]
33210#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33211#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33213pub const fn _mm_mask_cmpeq_epi32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33214 _mm_mask_cmp_epi32_mask::<_MM_CMPINT_EQ>(k1, a, b)
33215}
33216
33217#[inline]
33221#[target_feature(enable = "avx512f")]
33222#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33223#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33225pub const fn _mm512_cmpneq_epi32_mask(a: __m512i, b: __m512i) -> __mmask16 {
33226 unsafe { simd_bitmask::<i32x16, _>(simd_ne(a.as_i32x16(), b.as_i32x16())) }
33227}
33228
33229#[inline]
33233#[target_feature(enable = "avx512f")]
33234#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33235#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33237pub const fn _mm512_mask_cmpneq_epi32_mask(k1: __mmask16, a: __m512i, b: __m512i) -> __mmask16 {
33238 _mm512_mask_cmp_epi32_mask::<_MM_CMPINT_NE>(k1, a, b)
33239}
33240
33241#[inline]
33245#[target_feature(enable = "avx512f,avx512vl")]
33246#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33247#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33249pub const fn _mm256_cmpneq_epi32_mask(a: __m256i, b: __m256i) -> __mmask8 {
33250 unsafe { simd_bitmask::<i32x8, _>(simd_ne(a.as_i32x8(), b.as_i32x8())) }
33251}
33252
33253#[inline]
33257#[target_feature(enable = "avx512f,avx512vl")]
33258#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33259#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33261pub const fn _mm256_mask_cmpneq_epi32_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33262 _mm256_mask_cmp_epi32_mask::<_MM_CMPINT_NE>(k1, a, b)
33263}
33264
33265#[inline]
33269#[target_feature(enable = "avx512f,avx512vl")]
33270#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33271#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33273pub const fn _mm_cmpneq_epi32_mask(a: __m128i, b: __m128i) -> __mmask8 {
33274 unsafe { simd_bitmask::<i32x4, _>(simd_ne(a.as_i32x4(), b.as_i32x4())) }
33275}
33276
33277#[inline]
33281#[target_feature(enable = "avx512f,avx512vl")]
33282#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33283#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33285pub const fn _mm_mask_cmpneq_epi32_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33286 _mm_mask_cmp_epi32_mask::<_MM_CMPINT_NE>(k1, a, b)
33287}
33288
33289#[inline]
33293#[target_feature(enable = "avx512f")]
33294#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33295#[rustc_legacy_const_generics(2)]
33296#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33297#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33298pub const fn _mm512_cmp_epi32_mask<const IMM3: _MM_CMPINT_ENUM>(
33299 a: __m512i,
33300 b: __m512i,
33301) -> __mmask16 {
33302 unsafe {
33303 static_assert_uimm_bits!(IMM3, 3);
33304 let a = a.as_i32x16();
33305 let b = b.as_i32x16();
33306 let r = match IMM3 {
33307 0 => simd_eq(a, b),
33308 1 => simd_lt(a, b),
33309 2 => simd_le(a, b),
33310 3 => i32x16::ZERO,
33311 4 => simd_ne(a, b),
33312 5 => simd_ge(a, b),
33313 6 => simd_gt(a, b),
33314 _ => i32x16::splat(-1),
33315 };
33316 simd_bitmask(r)
33317 }
33318}
33319
33320#[inline]
33324#[target_feature(enable = "avx512f")]
33325#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33326#[rustc_legacy_const_generics(3)]
33327#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33328#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33329pub const fn _mm512_mask_cmp_epi32_mask<const IMM3: _MM_CMPINT_ENUM>(
33330 k1: __mmask16,
33331 a: __m512i,
33332 b: __m512i,
33333) -> __mmask16 {
33334 unsafe {
33335 static_assert_uimm_bits!(IMM3, 3);
33336 let a = a.as_i32x16();
33337 let b = b.as_i32x16();
33338 let k1 = simd_select_bitmask(k1, i32x16::splat(-1), i32x16::ZERO);
33339 let r = match IMM3 {
33340 0 => simd_and(k1, simd_eq(a, b)),
33341 1 => simd_and(k1, simd_lt(a, b)),
33342 2 => simd_and(k1, simd_le(a, b)),
33343 3 => i32x16::ZERO,
33344 4 => simd_and(k1, simd_ne(a, b)),
33345 5 => simd_and(k1, simd_ge(a, b)),
33346 6 => simd_and(k1, simd_gt(a, b)),
33347 _ => k1,
33348 };
33349 simd_bitmask(r)
33350 }
33351}
33352
33353#[inline]
33357#[target_feature(enable = "avx512f,avx512vl")]
33358#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33359#[rustc_legacy_const_generics(2)]
33360#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33361#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33362pub const fn _mm256_cmp_epi32_mask<const IMM3: _MM_CMPINT_ENUM>(
33363 a: __m256i,
33364 b: __m256i,
33365) -> __mmask8 {
33366 unsafe {
33367 static_assert_uimm_bits!(IMM3, 3);
33368 let a = a.as_i32x8();
33369 let b = b.as_i32x8();
33370 let r = match IMM3 {
33371 0 => simd_eq(a, b),
33372 1 => simd_lt(a, b),
33373 2 => simd_le(a, b),
33374 3 => i32x8::ZERO,
33375 4 => simd_ne(a, b),
33376 5 => simd_ge(a, b),
33377 6 => simd_gt(a, b),
33378 _ => i32x8::splat(-1),
33379 };
33380 simd_bitmask(r)
33381 }
33382}
33383
33384#[inline]
33388#[target_feature(enable = "avx512f,avx512vl")]
33389#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33390#[rustc_legacy_const_generics(3)]
33391#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33392#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33393pub const fn _mm256_mask_cmp_epi32_mask<const IMM3: _MM_CMPINT_ENUM>(
33394 k1: __mmask8,
33395 a: __m256i,
33396 b: __m256i,
33397) -> __mmask8 {
33398 unsafe {
33399 static_assert_uimm_bits!(IMM3, 3);
33400 let a = a.as_i32x8();
33401 let b = b.as_i32x8();
33402 let k1 = simd_select_bitmask(k1, i32x8::splat(-1), i32x8::ZERO);
33403 let r = match IMM3 {
33404 0 => simd_and(k1, simd_eq(a, b)),
33405 1 => simd_and(k1, simd_lt(a, b)),
33406 2 => simd_and(k1, simd_le(a, b)),
33407 3 => i32x8::ZERO,
33408 4 => simd_and(k1, simd_ne(a, b)),
33409 5 => simd_and(k1, simd_ge(a, b)),
33410 6 => simd_and(k1, simd_gt(a, b)),
33411 _ => k1,
33412 };
33413 simd_bitmask(r)
33414 }
33415}
33416
33417#[inline]
33421#[target_feature(enable = "avx512f,avx512vl")]
33422#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33423#[rustc_legacy_const_generics(2)]
33424#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33425#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33426pub const fn _mm_cmp_epi32_mask<const IMM3: _MM_CMPINT_ENUM>(a: __m128i, b: __m128i) -> __mmask8 {
33427 unsafe {
33428 static_assert_uimm_bits!(IMM3, 3);
33429 let a = a.as_i32x4();
33430 let b = b.as_i32x4();
33431 let r = match IMM3 {
33432 0 => simd_eq(a, b),
33433 1 => simd_lt(a, b),
33434 2 => simd_le(a, b),
33435 3 => i32x4::ZERO,
33436 4 => simd_ne(a, b),
33437 5 => simd_ge(a, b),
33438 6 => simd_gt(a, b),
33439 _ => i32x4::splat(-1),
33440 };
33441 simd_bitmask(r)
33442 }
33443}
33444
33445#[inline]
33449#[target_feature(enable = "avx512f,avx512vl")]
33450#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33451#[rustc_legacy_const_generics(3)]
33452#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33453#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33454pub const fn _mm_mask_cmp_epi32_mask<const IMM3: _MM_CMPINT_ENUM>(
33455 k1: __mmask8,
33456 a: __m128i,
33457 b: __m128i,
33458) -> __mmask8 {
33459 unsafe {
33460 static_assert_uimm_bits!(IMM3, 3);
33461 let a = a.as_i32x4();
33462 let b = b.as_i32x4();
33463 let k1 = simd_select_bitmask(k1, i32x4::splat(-1), i32x4::ZERO);
33464 let r = match IMM3 {
33465 0 => simd_and(k1, simd_eq(a, b)),
33466 1 => simd_and(k1, simd_lt(a, b)),
33467 2 => simd_and(k1, simd_le(a, b)),
33468 3 => i32x4::ZERO,
33469 4 => simd_and(k1, simd_ne(a, b)),
33470 5 => simd_and(k1, simd_ge(a, b)),
33471 6 => simd_and(k1, simd_gt(a, b)),
33472 _ => k1,
33473 };
33474 simd_bitmask(r)
33475 }
33476}
33477
33478#[inline]
33482#[target_feature(enable = "avx512f")]
33483#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33484#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33486pub const fn _mm512_cmplt_epu64_mask(a: __m512i, b: __m512i) -> __mmask8 {
33487 unsafe { simd_bitmask::<__m512i, _>(simd_lt(a.as_u64x8(), b.as_u64x8())) }
33488}
33489
33490#[inline]
33494#[target_feature(enable = "avx512f")]
33495#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33496#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33498pub const fn _mm512_mask_cmplt_epu64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
33499 _mm512_mask_cmp_epu64_mask::<_MM_CMPINT_LT>(k1, a, b)
33500}
33501
33502#[inline]
33506#[target_feature(enable = "avx512f,avx512vl")]
33507#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33508#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33510pub const fn _mm256_cmplt_epu64_mask(a: __m256i, b: __m256i) -> __mmask8 {
33511 unsafe { simd_bitmask::<__m256i, _>(simd_lt(a.as_u64x4(), b.as_u64x4())) }
33512}
33513
33514#[inline]
33518#[target_feature(enable = "avx512f,avx512vl")]
33519#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33520#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33522pub const fn _mm256_mask_cmplt_epu64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33523 _mm256_mask_cmp_epu64_mask::<_MM_CMPINT_LT>(k1, a, b)
33524}
33525
33526#[inline]
33530#[target_feature(enable = "avx512f,avx512vl")]
33531#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33532#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33534pub const fn _mm_cmplt_epu64_mask(a: __m128i, b: __m128i) -> __mmask8 {
33535 unsafe { simd_bitmask::<__m128i, _>(simd_lt(a.as_u64x2(), b.as_u64x2())) }
33536}
33537
33538#[inline]
33542#[target_feature(enable = "avx512f,avx512vl")]
33543#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33544#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33546pub const fn _mm_mask_cmplt_epu64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33547 _mm_mask_cmp_epu64_mask::<_MM_CMPINT_LT>(k1, a, b)
33548}
33549
33550#[inline]
33554#[target_feature(enable = "avx512f")]
33555#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33556#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33558pub const fn _mm512_cmpgt_epu64_mask(a: __m512i, b: __m512i) -> __mmask8 {
33559 unsafe { simd_bitmask::<__m512i, _>(simd_gt(a.as_u64x8(), b.as_u64x8())) }
33560}
33561
33562#[inline]
33566#[target_feature(enable = "avx512f")]
33567#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33568#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33570pub const fn _mm512_mask_cmpgt_epu64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
33571 _mm512_mask_cmp_epu64_mask::<_MM_CMPINT_NLE>(k1, a, b)
33572}
33573
33574#[inline]
33578#[target_feature(enable = "avx512f,avx512vl")]
33579#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33580#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33582pub const fn _mm256_cmpgt_epu64_mask(a: __m256i, b: __m256i) -> __mmask8 {
33583 unsafe { simd_bitmask::<__m256i, _>(simd_gt(a.as_u64x4(), b.as_u64x4())) }
33584}
33585
33586#[inline]
33590#[target_feature(enable = "avx512f,avx512vl")]
33591#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33592#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33594pub const fn _mm256_mask_cmpgt_epu64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33595 _mm256_mask_cmp_epu64_mask::<_MM_CMPINT_NLE>(k1, a, b)
33596}
33597
33598#[inline]
33602#[target_feature(enable = "avx512f,avx512vl")]
33603#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33604#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33606pub const fn _mm_cmpgt_epu64_mask(a: __m128i, b: __m128i) -> __mmask8 {
33607 unsafe { simd_bitmask::<__m128i, _>(simd_gt(a.as_u64x2(), b.as_u64x2())) }
33608}
33609
33610#[inline]
33614#[target_feature(enable = "avx512f,avx512vl")]
33615#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33616#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33618pub const fn _mm_mask_cmpgt_epu64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33619 _mm_mask_cmp_epu64_mask::<_MM_CMPINT_NLE>(k1, a, b)
33620}
33621
33622#[inline]
33626#[target_feature(enable = "avx512f")]
33627#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33628#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33630pub const fn _mm512_cmple_epu64_mask(a: __m512i, b: __m512i) -> __mmask8 {
33631 unsafe { simd_bitmask::<__m512i, _>(simd_le(a.as_u64x8(), b.as_u64x8())) }
33632}
33633
33634#[inline]
33638#[target_feature(enable = "avx512f")]
33639#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33640#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33642pub const fn _mm512_mask_cmple_epu64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
33643 _mm512_mask_cmp_epu64_mask::<_MM_CMPINT_LE>(k1, a, b)
33644}
33645
33646#[inline]
33650#[target_feature(enable = "avx512f,avx512vl")]
33651#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33652#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33654pub const fn _mm256_cmple_epu64_mask(a: __m256i, b: __m256i) -> __mmask8 {
33655 unsafe { simd_bitmask::<__m256i, _>(simd_le(a.as_u64x4(), b.as_u64x4())) }
33656}
33657
33658#[inline]
33662#[target_feature(enable = "avx512f,avx512vl")]
33663#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33664#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33666pub const fn _mm256_mask_cmple_epu64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33667 _mm256_mask_cmp_epu64_mask::<_MM_CMPINT_LE>(k1, a, b)
33668}
33669
33670#[inline]
33674#[target_feature(enable = "avx512f,avx512vl")]
33675#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33676#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33678pub const fn _mm_cmple_epu64_mask(a: __m128i, b: __m128i) -> __mmask8 {
33679 unsafe { simd_bitmask::<__m128i, _>(simd_le(a.as_u64x2(), b.as_u64x2())) }
33680}
33681
33682#[inline]
33686#[target_feature(enable = "avx512f,avx512vl")]
33687#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33688#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33690pub const fn _mm_mask_cmple_epu64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33691 _mm_mask_cmp_epu64_mask::<_MM_CMPINT_LE>(k1, a, b)
33692}
33693
33694#[inline]
33698#[target_feature(enable = "avx512f")]
33699#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33700#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33702pub const fn _mm512_cmpge_epu64_mask(a: __m512i, b: __m512i) -> __mmask8 {
33703 unsafe { simd_bitmask::<__m512i, _>(simd_ge(a.as_u64x8(), b.as_u64x8())) }
33704}
33705
33706#[inline]
33710#[target_feature(enable = "avx512f")]
33711#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33712#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33714pub const fn _mm512_mask_cmpge_epu64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
33715 _mm512_mask_cmp_epu64_mask::<_MM_CMPINT_NLT>(k1, a, b)
33716}
33717
33718#[inline]
33722#[target_feature(enable = "avx512f,avx512vl")]
33723#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33724#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33726pub const fn _mm256_cmpge_epu64_mask(a: __m256i, b: __m256i) -> __mmask8 {
33727 unsafe { simd_bitmask::<__m256i, _>(simd_ge(a.as_u64x4(), b.as_u64x4())) }
33728}
33729
33730#[inline]
33734#[target_feature(enable = "avx512f,avx512vl")]
33735#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33736#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33738pub const fn _mm256_mask_cmpge_epu64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33739 _mm256_mask_cmp_epu64_mask::<_MM_CMPINT_NLT>(k1, a, b)
33740}
33741
33742#[inline]
33746#[target_feature(enable = "avx512f,avx512vl")]
33747#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33748#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33750pub const fn _mm_cmpge_epu64_mask(a: __m128i, b: __m128i) -> __mmask8 {
33751 unsafe { simd_bitmask::<__m128i, _>(simd_ge(a.as_u64x2(), b.as_u64x2())) }
33752}
33753
33754#[inline]
33758#[target_feature(enable = "avx512f,avx512vl")]
33759#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33760#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33762pub const fn _mm_mask_cmpge_epu64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33763 _mm_mask_cmp_epu64_mask::<_MM_CMPINT_NLT>(k1, a, b)
33764}
33765
33766#[inline]
33770#[target_feature(enable = "avx512f")]
33771#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33772#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33774pub const fn _mm512_cmpeq_epu64_mask(a: __m512i, b: __m512i) -> __mmask8 {
33775 unsafe { simd_bitmask::<__m512i, _>(simd_eq(a.as_u64x8(), b.as_u64x8())) }
33776}
33777
33778#[inline]
33782#[target_feature(enable = "avx512f")]
33783#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33784#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33786pub const fn _mm512_mask_cmpeq_epu64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
33787 _mm512_mask_cmp_epu64_mask::<_MM_CMPINT_EQ>(k1, a, b)
33788}
33789
33790#[inline]
33794#[target_feature(enable = "avx512f,avx512vl")]
33795#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33796#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33798pub const fn _mm256_cmpeq_epu64_mask(a: __m256i, b: __m256i) -> __mmask8 {
33799 unsafe { simd_bitmask::<__m256i, _>(simd_eq(a.as_u64x4(), b.as_u64x4())) }
33800}
33801
33802#[inline]
33806#[target_feature(enable = "avx512f,avx512vl")]
33807#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33808#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33810pub const fn _mm256_mask_cmpeq_epu64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33811 _mm256_mask_cmp_epu64_mask::<_MM_CMPINT_EQ>(k1, a, b)
33812}
33813
33814#[inline]
33818#[target_feature(enable = "avx512f,avx512vl")]
33819#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33820#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33822pub const fn _mm_cmpeq_epu64_mask(a: __m128i, b: __m128i) -> __mmask8 {
33823 unsafe { simd_bitmask::<__m128i, _>(simd_eq(a.as_u64x2(), b.as_u64x2())) }
33824}
33825
33826#[inline]
33830#[target_feature(enable = "avx512f,avx512vl")]
33831#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33832#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33834pub const fn _mm_mask_cmpeq_epu64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33835 _mm_mask_cmp_epu64_mask::<_MM_CMPINT_EQ>(k1, a, b)
33836}
33837
33838#[inline]
33842#[target_feature(enable = "avx512f")]
33843#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33844#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33846pub const fn _mm512_cmpneq_epu64_mask(a: __m512i, b: __m512i) -> __mmask8 {
33847 unsafe { simd_bitmask::<__m512i, _>(simd_ne(a.as_u64x8(), b.as_u64x8())) }
33848}
33849
33850#[inline]
33854#[target_feature(enable = "avx512f")]
33855#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33856#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33858pub const fn _mm512_mask_cmpneq_epu64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
33859 _mm512_mask_cmp_epu64_mask::<_MM_CMPINT_NE>(k1, a, b)
33860}
33861
33862#[inline]
33866#[target_feature(enable = "avx512f,avx512vl")]
33867#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33868#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33870pub const fn _mm256_cmpneq_epu64_mask(a: __m256i, b: __m256i) -> __mmask8 {
33871 unsafe { simd_bitmask::<__m256i, _>(simd_ne(a.as_u64x4(), b.as_u64x4())) }
33872}
33873
33874#[inline]
33878#[target_feature(enable = "avx512f,avx512vl")]
33879#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33880#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33882pub const fn _mm256_mask_cmpneq_epu64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
33883 _mm256_mask_cmp_epu64_mask::<_MM_CMPINT_NE>(k1, a, b)
33884}
33885
33886#[inline]
33890#[target_feature(enable = "avx512f,avx512vl")]
33891#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33892#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33894pub const fn _mm_cmpneq_epu64_mask(a: __m128i, b: __m128i) -> __mmask8 {
33895 unsafe { simd_bitmask::<__m128i, _>(simd_ne(a.as_u64x2(), b.as_u64x2())) }
33896}
33897
33898#[inline]
33902#[target_feature(enable = "avx512f,avx512vl")]
33903#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33904#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33906pub const fn _mm_mask_cmpneq_epu64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
33907 _mm_mask_cmp_epu64_mask::<_MM_CMPINT_NE>(k1, a, b)
33908}
33909
33910#[inline]
33914#[target_feature(enable = "avx512f")]
33915#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33916#[rustc_legacy_const_generics(2)]
33917#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33918#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33919pub const fn _mm512_cmp_epu64_mask<const IMM3: _MM_CMPINT_ENUM>(
33920 a: __m512i,
33921 b: __m512i,
33922) -> __mmask8 {
33923 unsafe {
33924 static_assert_uimm_bits!(IMM3, 3);
33925 let a = a.as_u64x8();
33926 let b = b.as_u64x8();
33927 let r = match IMM3 {
33928 0 => simd_eq(a, b),
33929 1 => simd_lt(a, b),
33930 2 => simd_le(a, b),
33931 3 => i64x8::ZERO,
33932 4 => simd_ne(a, b),
33933 5 => simd_ge(a, b),
33934 6 => simd_gt(a, b),
33935 _ => i64x8::splat(-1),
33936 };
33937 simd_bitmask(r)
33938 }
33939}
33940
33941#[inline]
33945#[target_feature(enable = "avx512f")]
33946#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33947#[rustc_legacy_const_generics(3)]
33948#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33949#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33950pub const fn _mm512_mask_cmp_epu64_mask<const IMM3: _MM_CMPINT_ENUM>(
33951 k1: __mmask8,
33952 a: __m512i,
33953 b: __m512i,
33954) -> __mmask8 {
33955 unsafe {
33956 static_assert_uimm_bits!(IMM3, 3);
33957 let a = a.as_u64x8();
33958 let b = b.as_u64x8();
33959 let k1 = simd_select_bitmask(k1, i64x8::splat(-1), i64x8::ZERO);
33960 let r = match IMM3 {
33961 0 => simd_and(k1, simd_eq(a, b)),
33962 1 => simd_and(k1, simd_lt(a, b)),
33963 2 => simd_and(k1, simd_le(a, b)),
33964 3 => i64x8::ZERO,
33965 4 => simd_and(k1, simd_ne(a, b)),
33966 5 => simd_and(k1, simd_ge(a, b)),
33967 6 => simd_and(k1, simd_gt(a, b)),
33968 _ => k1,
33969 };
33970 simd_bitmask(r)
33971 }
33972}
33973
33974#[inline]
33978#[target_feature(enable = "avx512f,avx512vl")]
33979#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
33980#[rustc_legacy_const_generics(2)]
33981#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
33982#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
33983pub const fn _mm256_cmp_epu64_mask<const IMM3: _MM_CMPINT_ENUM>(
33984 a: __m256i,
33985 b: __m256i,
33986) -> __mmask8 {
33987 unsafe {
33988 static_assert_uimm_bits!(IMM3, 3);
33989 let a = a.as_u64x4();
33990 let b = b.as_u64x4();
33991 let r = match IMM3 {
33992 0 => simd_eq(a, b),
33993 1 => simd_lt(a, b),
33994 2 => simd_le(a, b),
33995 3 => i64x4::ZERO,
33996 4 => simd_ne(a, b),
33997 5 => simd_ge(a, b),
33998 6 => simd_gt(a, b),
33999 _ => i64x4::splat(-1),
34000 };
34001 simd_bitmask(r)
34002 }
34003}
34004
34005#[inline]
34009#[target_feature(enable = "avx512f,avx512vl")]
34010#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34011#[rustc_legacy_const_generics(3)]
34012#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34013#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34014pub const fn _mm256_mask_cmp_epu64_mask<const IMM3: _MM_CMPINT_ENUM>(
34015 k1: __mmask8,
34016 a: __m256i,
34017 b: __m256i,
34018) -> __mmask8 {
34019 unsafe {
34020 static_assert_uimm_bits!(IMM3, 3);
34021 let a = a.as_u64x4();
34022 let b = b.as_u64x4();
34023 let k1 = simd_select_bitmask(k1, i64x4::splat(-1), i64x4::ZERO);
34024 let r = match IMM3 {
34025 0 => simd_and(k1, simd_eq(a, b)),
34026 1 => simd_and(k1, simd_lt(a, b)),
34027 2 => simd_and(k1, simd_le(a, b)),
34028 3 => i64x4::ZERO,
34029 4 => simd_and(k1, simd_ne(a, b)),
34030 5 => simd_and(k1, simd_ge(a, b)),
34031 6 => simd_and(k1, simd_gt(a, b)),
34032 _ => k1,
34033 };
34034 simd_bitmask(r)
34035 }
34036}
34037
34038#[inline]
34042#[target_feature(enable = "avx512f,avx512vl")]
34043#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34044#[rustc_legacy_const_generics(2)]
34045#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34046#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34047pub const fn _mm_cmp_epu64_mask<const IMM3: _MM_CMPINT_ENUM>(a: __m128i, b: __m128i) -> __mmask8 {
34048 unsafe {
34049 static_assert_uimm_bits!(IMM3, 3);
34050 let a = a.as_u64x2();
34051 let b = b.as_u64x2();
34052 let r = match IMM3 {
34053 0 => simd_eq(a, b),
34054 1 => simd_lt(a, b),
34055 2 => simd_le(a, b),
34056 3 => i64x2::ZERO,
34057 4 => simd_ne(a, b),
34058 5 => simd_ge(a, b),
34059 6 => simd_gt(a, b),
34060 _ => i64x2::splat(-1),
34061 };
34062 simd_bitmask(r)
34063 }
34064}
34065
34066#[inline]
34070#[target_feature(enable = "avx512f,avx512vl")]
34071#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34072#[rustc_legacy_const_generics(3)]
34073#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34074#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34075pub const fn _mm_mask_cmp_epu64_mask<const IMM3: _MM_CMPINT_ENUM>(
34076 k1: __mmask8,
34077 a: __m128i,
34078 b: __m128i,
34079) -> __mmask8 {
34080 unsafe {
34081 static_assert_uimm_bits!(IMM3, 3);
34082 let a = a.as_u64x2();
34083 let b = b.as_u64x2();
34084 let k1 = simd_select_bitmask(k1, i64x2::splat(-1), i64x2::ZERO);
34085 let r = match IMM3 {
34086 0 => simd_and(k1, simd_eq(a, b)),
34087 1 => simd_and(k1, simd_lt(a, b)),
34088 2 => simd_and(k1, simd_le(a, b)),
34089 3 => i64x2::ZERO,
34090 4 => simd_and(k1, simd_ne(a, b)),
34091 5 => simd_and(k1, simd_ge(a, b)),
34092 6 => simd_and(k1, simd_gt(a, b)),
34093 _ => k1,
34094 };
34095 simd_bitmask(r)
34096 }
34097}
34098
34099#[inline]
34103#[target_feature(enable = "avx512f")]
34104#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34105#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34107pub const fn _mm512_cmplt_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
34108 unsafe { simd_bitmask::<__m512i, _>(simd_lt(a.as_i64x8(), b.as_i64x8())) }
34109}
34110
34111#[inline]
34115#[target_feature(enable = "avx512f")]
34116#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34117#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34119pub const fn _mm512_mask_cmplt_epi64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
34120 _mm512_mask_cmp_epi64_mask::<_MM_CMPINT_LT>(k1, a, b)
34121}
34122
34123#[inline]
34127#[target_feature(enable = "avx512f,avx512vl")]
34128#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34129#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34131pub const fn _mm256_cmplt_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
34132 unsafe { simd_bitmask::<__m256i, _>(simd_lt(a.as_i64x4(), b.as_i64x4())) }
34133}
34134
34135#[inline]
34139#[target_feature(enable = "avx512f,avx512vl")]
34140#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34141#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34143pub const fn _mm256_mask_cmplt_epi64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
34144 _mm256_mask_cmp_epi64_mask::<_MM_CMPINT_LT>(k1, a, b)
34145}
34146
34147#[inline]
34151#[target_feature(enable = "avx512f,avx512vl")]
34152#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34153#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34155pub const fn _mm_cmplt_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
34156 unsafe { simd_bitmask::<__m128i, _>(simd_lt(a.as_i64x2(), b.as_i64x2())) }
34157}
34158
34159#[inline]
34163#[target_feature(enable = "avx512f,avx512vl")]
34164#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34165#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34167pub const fn _mm_mask_cmplt_epi64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
34168 _mm_mask_cmp_epi64_mask::<_MM_CMPINT_LT>(k1, a, b)
34169}
34170
34171#[inline]
34175#[target_feature(enable = "avx512f")]
34176#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34177#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34179pub const fn _mm512_cmpgt_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
34180 unsafe { simd_bitmask::<__m512i, _>(simd_gt(a.as_i64x8(), b.as_i64x8())) }
34181}
34182
34183#[inline]
34187#[target_feature(enable = "avx512f")]
34188#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34189#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34191pub const fn _mm512_mask_cmpgt_epi64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
34192 _mm512_mask_cmp_epi64_mask::<_MM_CMPINT_NLE>(k1, a, b)
34193}
34194
34195#[inline]
34199#[target_feature(enable = "avx512f,avx512vl")]
34200#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34201#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34203pub const fn _mm256_cmpgt_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
34204 unsafe { simd_bitmask::<__m256i, _>(simd_gt(a.as_i64x4(), b.as_i64x4())) }
34205}
34206
34207#[inline]
34211#[target_feature(enable = "avx512f,avx512vl")]
34212#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34213#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34215pub const fn _mm256_mask_cmpgt_epi64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
34216 _mm256_mask_cmp_epi64_mask::<_MM_CMPINT_NLE>(k1, a, b)
34217}
34218
34219#[inline]
34223#[target_feature(enable = "avx512f,avx512vl")]
34224#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34225#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34227pub const fn _mm_cmpgt_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
34228 unsafe { simd_bitmask::<__m128i, _>(simd_gt(a.as_i64x2(), b.as_i64x2())) }
34229}
34230
34231#[inline]
34235#[target_feature(enable = "avx512f,avx512vl")]
34236#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34237#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34239pub const fn _mm_mask_cmpgt_epi64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
34240 _mm_mask_cmp_epi64_mask::<_MM_CMPINT_NLE>(k1, a, b)
34241}
34242
34243#[inline]
34247#[target_feature(enable = "avx512f")]
34248#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34249#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34251pub const fn _mm512_cmple_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
34252 unsafe { simd_bitmask::<__m512i, _>(simd_le(a.as_i64x8(), b.as_i64x8())) }
34253}
34254
34255#[inline]
34259#[target_feature(enable = "avx512f")]
34260#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34261#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34263pub const fn _mm512_mask_cmple_epi64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
34264 _mm512_mask_cmp_epi64_mask::<_MM_CMPINT_LE>(k1, a, b)
34265}
34266
34267#[inline]
34271#[target_feature(enable = "avx512f,avx512vl")]
34272#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34273#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34275pub const fn _mm256_cmple_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
34276 unsafe { simd_bitmask::<__m256i, _>(simd_le(a.as_i64x4(), b.as_i64x4())) }
34277}
34278
34279#[inline]
34283#[target_feature(enable = "avx512f,avx512vl")]
34284#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34285#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34287pub const fn _mm256_mask_cmple_epi64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
34288 _mm256_mask_cmp_epi64_mask::<_MM_CMPINT_LE>(k1, a, b)
34289}
34290
34291#[inline]
34295#[target_feature(enable = "avx512f,avx512vl")]
34296#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34297#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34299pub const fn _mm_cmple_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
34300 unsafe { simd_bitmask::<__m128i, _>(simd_le(a.as_i64x2(), b.as_i64x2())) }
34301}
34302
34303#[inline]
34307#[target_feature(enable = "avx512f,avx512vl")]
34308#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34309#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34311pub const fn _mm_mask_cmple_epi64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
34312 _mm_mask_cmp_epi64_mask::<_MM_CMPINT_LE>(k1, a, b)
34313}
34314
34315#[inline]
34319#[target_feature(enable = "avx512f")]
34320#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34321#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34323pub const fn _mm512_cmpge_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
34324 unsafe { simd_bitmask::<__m512i, _>(simd_ge(a.as_i64x8(), b.as_i64x8())) }
34325}
34326
34327#[inline]
34331#[target_feature(enable = "avx512f")]
34332#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34333#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34335pub const fn _mm512_mask_cmpge_epi64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
34336 _mm512_mask_cmp_epi64_mask::<_MM_CMPINT_NLT>(k1, a, b)
34337}
34338
34339#[inline]
34343#[target_feature(enable = "avx512f,avx512vl")]
34344#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34345#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34347pub const fn _mm256_cmpge_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
34348 unsafe { simd_bitmask::<__m256i, _>(simd_ge(a.as_i64x4(), b.as_i64x4())) }
34349}
34350
34351#[inline]
34355#[target_feature(enable = "avx512f,avx512vl")]
34356#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34357#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34359pub const fn _mm256_mask_cmpge_epi64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
34360 _mm256_mask_cmp_epi64_mask::<_MM_CMPINT_NLT>(k1, a, b)
34361}
34362
34363#[inline]
34367#[target_feature(enable = "avx512f,avx512vl")]
34368#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34369#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34371pub const fn _mm_cmpge_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
34372 unsafe { simd_bitmask::<__m128i, _>(simd_ge(a.as_i64x2(), b.as_i64x2())) }
34373}
34374
34375#[inline]
34379#[target_feature(enable = "avx512f,avx512vl")]
34380#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34381#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34383pub const fn _mm_mask_cmpge_epi64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
34384 _mm_mask_cmp_epi64_mask::<_MM_CMPINT_NLT>(k1, a, b)
34385}
34386
34387#[inline]
34391#[target_feature(enable = "avx512f")]
34392#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34393#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34395pub const fn _mm512_cmpeq_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
34396 unsafe { simd_bitmask::<__m512i, _>(simd_eq(a.as_i64x8(), b.as_i64x8())) }
34397}
34398
34399#[inline]
34403#[target_feature(enable = "avx512f")]
34404#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34405#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34407pub const fn _mm512_mask_cmpeq_epi64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
34408 _mm512_mask_cmp_epi64_mask::<_MM_CMPINT_EQ>(k1, a, b)
34409}
34410
34411#[inline]
34415#[target_feature(enable = "avx512f,avx512vl")]
34416#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34417#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34419pub const fn _mm256_cmpeq_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
34420 unsafe { simd_bitmask::<__m256i, _>(simd_eq(a.as_i64x4(), b.as_i64x4())) }
34421}
34422
34423#[inline]
34427#[target_feature(enable = "avx512f,avx512vl")]
34428#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34429#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34431pub const fn _mm256_mask_cmpeq_epi64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
34432 _mm256_mask_cmp_epi64_mask::<_MM_CMPINT_EQ>(k1, a, b)
34433}
34434
34435#[inline]
34439#[target_feature(enable = "avx512f,avx512vl")]
34440#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34441#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34443pub const fn _mm_cmpeq_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
34444 unsafe { simd_bitmask::<__m128i, _>(simd_eq(a.as_i64x2(), b.as_i64x2())) }
34445}
34446
34447#[inline]
34451#[target_feature(enable = "avx512f,avx512vl")]
34452#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34453#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34455pub const fn _mm_mask_cmpeq_epi64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
34456 _mm_mask_cmp_epi64_mask::<_MM_CMPINT_EQ>(k1, a, b)
34457}
34458
34459#[inline]
34463#[target_feature(enable = "avx512f")]
34464#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34465#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34467pub const fn _mm512_cmpneq_epi64_mask(a: __m512i, b: __m512i) -> __mmask8 {
34468 unsafe { simd_bitmask::<__m512i, _>(simd_ne(a.as_i64x8(), b.as_i64x8())) }
34469}
34470
34471#[inline]
34475#[target_feature(enable = "avx512f")]
34476#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34477#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34479pub const fn _mm512_mask_cmpneq_epi64_mask(k1: __mmask8, a: __m512i, b: __m512i) -> __mmask8 {
34480 _mm512_mask_cmp_epi64_mask::<_MM_CMPINT_NE>(k1, a, b)
34481}
34482
34483#[inline]
34487#[target_feature(enable = "avx512f,avx512vl")]
34488#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34489#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34491pub const fn _mm256_cmpneq_epi64_mask(a: __m256i, b: __m256i) -> __mmask8 {
34492 unsafe { simd_bitmask::<__m256i, _>(simd_ne(a.as_i64x4(), b.as_i64x4())) }
34493}
34494
34495#[inline]
34499#[target_feature(enable = "avx512f,avx512vl")]
34500#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34501#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34503pub const fn _mm256_mask_cmpneq_epi64_mask(k1: __mmask8, a: __m256i, b: __m256i) -> __mmask8 {
34504 _mm256_mask_cmp_epi64_mask::<_MM_CMPINT_NE>(k1, a, b)
34505}
34506
34507#[inline]
34511#[target_feature(enable = "avx512f,avx512vl")]
34512#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34513#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34515pub const fn _mm_cmpneq_epi64_mask(a: __m128i, b: __m128i) -> __mmask8 {
34516 unsafe { simd_bitmask::<__m128i, _>(simd_ne(a.as_i64x2(), b.as_i64x2())) }
34517}
34518
34519#[inline]
34523#[target_feature(enable = "avx512f,avx512vl")]
34524#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34525#[cfg_attr(test, assert_instr(vpcmp))] #[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34527pub const fn _mm_mask_cmpneq_epi64_mask(k1: __mmask8, a: __m128i, b: __m128i) -> __mmask8 {
34528 _mm_mask_cmp_epi64_mask::<_MM_CMPINT_NE>(k1, a, b)
34529}
34530
34531#[inline]
34535#[target_feature(enable = "avx512f")]
34536#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34537#[rustc_legacy_const_generics(2)]
34538#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34539#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34540pub const fn _mm512_cmp_epi64_mask<const IMM3: _MM_CMPINT_ENUM>(
34541 a: __m512i,
34542 b: __m512i,
34543) -> __mmask8 {
34544 unsafe {
34545 static_assert_uimm_bits!(IMM3, 3);
34546 let a = a.as_i64x8();
34547 let b = b.as_i64x8();
34548 let r = match IMM3 {
34549 0 => simd_eq(a, b),
34550 1 => simd_lt(a, b),
34551 2 => simd_le(a, b),
34552 3 => i64x8::ZERO,
34553 4 => simd_ne(a, b),
34554 5 => simd_ge(a, b),
34555 6 => simd_gt(a, b),
34556 _ => i64x8::splat(-1),
34557 };
34558 simd_bitmask(r)
34559 }
34560}
34561
34562#[inline]
34566#[target_feature(enable = "avx512f")]
34567#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34568#[rustc_legacy_const_generics(3)]
34569#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34570#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34571pub const fn _mm512_mask_cmp_epi64_mask<const IMM3: _MM_CMPINT_ENUM>(
34572 k1: __mmask8,
34573 a: __m512i,
34574 b: __m512i,
34575) -> __mmask8 {
34576 unsafe {
34577 static_assert_uimm_bits!(IMM3, 3);
34578 let a = a.as_i64x8();
34579 let b = b.as_i64x8();
34580 let k1 = simd_select_bitmask(k1, i64x8::splat(-1), i64x8::ZERO);
34581 let r = match IMM3 {
34582 0 => simd_and(k1, simd_eq(a, b)),
34583 1 => simd_and(k1, simd_lt(a, b)),
34584 2 => simd_and(k1, simd_le(a, b)),
34585 3 => i64x8::ZERO,
34586 4 => simd_and(k1, simd_ne(a, b)),
34587 5 => simd_and(k1, simd_ge(a, b)),
34588 6 => simd_and(k1, simd_gt(a, b)),
34589 _ => k1,
34590 };
34591 simd_bitmask(r)
34592 }
34593}
34594
34595#[inline]
34599#[target_feature(enable = "avx512f,avx512vl")]
34600#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34601#[rustc_legacy_const_generics(2)]
34602#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34603#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34604pub const fn _mm256_cmp_epi64_mask<const IMM3: _MM_CMPINT_ENUM>(
34605 a: __m256i,
34606 b: __m256i,
34607) -> __mmask8 {
34608 unsafe {
34609 static_assert_uimm_bits!(IMM3, 3);
34610 let a = a.as_i64x4();
34611 let b = b.as_i64x4();
34612 let r = match IMM3 {
34613 0 => simd_eq(a, b),
34614 1 => simd_lt(a, b),
34615 2 => simd_le(a, b),
34616 3 => i64x4::ZERO,
34617 4 => simd_ne(a, b),
34618 5 => simd_ge(a, b),
34619 6 => simd_gt(a, b),
34620 _ => i64x4::splat(-1),
34621 };
34622 simd_bitmask(r)
34623 }
34624}
34625
34626#[inline]
34630#[target_feature(enable = "avx512f,avx512vl")]
34631#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34632#[rustc_legacy_const_generics(3)]
34633#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34634#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34635pub const fn _mm256_mask_cmp_epi64_mask<const IMM3: _MM_CMPINT_ENUM>(
34636 k1: __mmask8,
34637 a: __m256i,
34638 b: __m256i,
34639) -> __mmask8 {
34640 unsafe {
34641 static_assert_uimm_bits!(IMM3, 3);
34642 let a = a.as_i64x4();
34643 let b = b.as_i64x4();
34644 let k1 = simd_select_bitmask(k1, i64x4::splat(-1), i64x4::ZERO);
34645 let r = match IMM3 {
34646 0 => simd_and(k1, simd_eq(a, b)),
34647 1 => simd_and(k1, simd_lt(a, b)),
34648 2 => simd_and(k1, simd_le(a, b)),
34649 3 => i64x4::ZERO,
34650 4 => simd_and(k1, simd_ne(a, b)),
34651 5 => simd_and(k1, simd_ge(a, b)),
34652 6 => simd_and(k1, simd_gt(a, b)),
34653 _ => k1,
34654 };
34655 simd_bitmask(r)
34656 }
34657}
34658
34659#[inline]
34663#[target_feature(enable = "avx512f,avx512vl")]
34664#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34665#[rustc_legacy_const_generics(2)]
34666#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34667#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34668pub const fn _mm_cmp_epi64_mask<const IMM3: _MM_CMPINT_ENUM>(a: __m128i, b: __m128i) -> __mmask8 {
34669 unsafe {
34670 static_assert_uimm_bits!(IMM3, 3);
34671 let a = a.as_i64x2();
34672 let b = b.as_i64x2();
34673 let r = match IMM3 {
34674 0 => simd_eq(a, b),
34675 1 => simd_lt(a, b),
34676 2 => simd_le(a, b),
34677 3 => i64x2::ZERO,
34678 4 => simd_ne(a, b),
34679 5 => simd_ge(a, b),
34680 6 => simd_gt(a, b),
34681 _ => i64x2::splat(-1),
34682 };
34683 simd_bitmask(r)
34684 }
34685}
34686
34687#[inline]
34691#[target_feature(enable = "avx512f,avx512vl")]
34692#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34693#[rustc_legacy_const_generics(3)]
34694#[cfg_attr(test, assert_instr(vpcmp, IMM3 = 0))]
34695#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34696pub const fn _mm_mask_cmp_epi64_mask<const IMM3: _MM_CMPINT_ENUM>(
34697 k1: __mmask8,
34698 a: __m128i,
34699 b: __m128i,
34700) -> __mmask8 {
34701 unsafe {
34702 static_assert_uimm_bits!(IMM3, 3);
34703 let a = a.as_i64x2();
34704 let b = b.as_i64x2();
34705 let k1 = simd_select_bitmask(k1, i64x2::splat(-1), i64x2::ZERO);
34706 let r = match IMM3 {
34707 0 => simd_and(k1, simd_eq(a, b)),
34708 1 => simd_and(k1, simd_lt(a, b)),
34709 2 => simd_and(k1, simd_le(a, b)),
34710 3 => i64x2::ZERO,
34711 4 => simd_and(k1, simd_ne(a, b)),
34712 5 => simd_and(k1, simd_ge(a, b)),
34713 6 => simd_and(k1, simd_gt(a, b)),
34714 _ => k1,
34715 };
34716 simd_bitmask(r)
34717 }
34718}
34719
34720#[inline]
34724#[target_feature(enable = "avx512f")]
34725#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34726#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34727pub const fn _mm512_reduce_add_epi32(a: __m512i) -> i32 {
34728 unsafe { simd_reduce_add_ordered(a.as_i32x16(), 0) }
34729}
34730
34731#[inline]
34735#[target_feature(enable = "avx512f")]
34736#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34737#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34738pub const fn _mm512_mask_reduce_add_epi32(k: __mmask16, a: __m512i) -> i32 {
34739 unsafe { simd_reduce_add_ordered(simd_select_bitmask(k, a.as_i32x16(), i32x16::ZERO), 0) }
34740}
34741
34742#[inline]
34746#[target_feature(enable = "avx512f")]
34747#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34748#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34749pub const fn _mm512_reduce_add_epi64(a: __m512i) -> i64 {
34750 unsafe { simd_reduce_add_ordered(a.as_i64x8(), 0) }
34751}
34752
34753#[inline]
34757#[target_feature(enable = "avx512f")]
34758#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34759#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34760pub const fn _mm512_mask_reduce_add_epi64(k: __mmask8, a: __m512i) -> i64 {
34761 unsafe { simd_reduce_add_ordered(simd_select_bitmask(k, a.as_i64x8(), i64x8::ZERO), 0) }
34762}
34763
34764#[inline]
34768#[target_feature(enable = "avx512f")]
34769#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34770#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34771pub const fn _mm512_reduce_add_ps(a: __m512) -> f32 {
34772 unsafe {
34773 let a = _mm256_add_ps(
34775 simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7]),
34776 simd_shuffle!(a, a, [8, 9, 10, 11, 12, 13, 14, 15]),
34777 );
34778 let a = _mm_add_ps(_mm256_extractf128_ps::<0>(a), _mm256_extractf128_ps::<1>(a));
34779 let a = _mm_add_ps(a, simd_shuffle!(a, a, [2, 3, 0, 1]));
34780 simd_extract!(a, 0, f32) + simd_extract!(a, 1, f32)
34781 }
34782}
34783
34784#[inline]
34788#[target_feature(enable = "avx512f")]
34789#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34790#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34791pub const fn _mm512_mask_reduce_add_ps(k: __mmask16, a: __m512) -> f32 {
34792 unsafe { _mm512_reduce_add_ps(simd_select_bitmask(k, a, _mm512_setzero_ps())) }
34793}
34794
34795#[inline]
34799#[target_feature(enable = "avx512f")]
34800#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34801#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34802pub const fn _mm512_reduce_add_pd(a: __m512d) -> f64 {
34803 unsafe {
34804 let a = _mm256_add_pd(
34805 _mm512_extractf64x4_pd::<0>(a),
34806 _mm512_extractf64x4_pd::<1>(a),
34807 );
34808 let a = _mm_add_pd(_mm256_extractf128_pd::<0>(a), _mm256_extractf128_pd::<1>(a));
34809 simd_extract!(a, 0, f64) + simd_extract!(a, 1, f64)
34810 }
34811}
34812
34813#[inline]
34817#[target_feature(enable = "avx512f")]
34818#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34819#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34820pub const fn _mm512_mask_reduce_add_pd(k: __mmask8, a: __m512d) -> f64 {
34821 unsafe { _mm512_reduce_add_pd(simd_select_bitmask(k, a, _mm512_setzero_pd())) }
34822}
34823
34824#[inline]
34828#[target_feature(enable = "avx512f")]
34829#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34830#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34831pub const fn _mm512_reduce_mul_epi32(a: __m512i) -> i32 {
34832 unsafe { simd_reduce_mul_ordered(a.as_i32x16(), 1) }
34833}
34834
34835#[inline]
34839#[target_feature(enable = "avx512f")]
34840#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34841#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34842pub const fn _mm512_mask_reduce_mul_epi32(k: __mmask16, a: __m512i) -> i32 {
34843 unsafe {
34844 simd_reduce_mul_ordered(
34845 simd_select_bitmask(k, a.as_i32x16(), _mm512_set1_epi32(1).as_i32x16()),
34846 1,
34847 )
34848 }
34849}
34850
34851#[inline]
34855#[target_feature(enable = "avx512f")]
34856#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34857#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34858pub const fn _mm512_reduce_mul_epi64(a: __m512i) -> i64 {
34859 unsafe { simd_reduce_mul_ordered(a.as_i64x8(), 1) }
34860}
34861
34862#[inline]
34866#[target_feature(enable = "avx512f")]
34867#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34868#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34869pub const fn _mm512_mask_reduce_mul_epi64(k: __mmask8, a: __m512i) -> i64 {
34870 unsafe {
34871 simd_reduce_mul_ordered(
34872 simd_select_bitmask(k, a.as_i64x8(), _mm512_set1_epi64(1).as_i64x8()),
34873 1,
34874 )
34875 }
34876}
34877
34878#[inline]
34882#[target_feature(enable = "avx512f")]
34883#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34884#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34885pub const fn _mm512_reduce_mul_ps(a: __m512) -> f32 {
34886 unsafe {
34887 let a = _mm256_mul_ps(
34889 simd_shuffle!(a, a, [0, 1, 2, 3, 4, 5, 6, 7]),
34890 simd_shuffle!(a, a, [8, 9, 10, 11, 12, 13, 14, 15]),
34891 );
34892 let a = _mm_mul_ps(_mm256_extractf128_ps::<0>(a), _mm256_extractf128_ps::<1>(a));
34893 let a = _mm_mul_ps(a, simd_shuffle!(a, a, [2, 3, 0, 1]));
34894 simd_extract!(a, 0, f32) * simd_extract!(a, 1, f32)
34895 }
34896}
34897
34898#[inline]
34902#[target_feature(enable = "avx512f")]
34903#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34904#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34905pub const fn _mm512_mask_reduce_mul_ps(k: __mmask16, a: __m512) -> f32 {
34906 unsafe { _mm512_reduce_mul_ps(simd_select_bitmask(k, a, _mm512_set1_ps(1.))) }
34907}
34908
34909#[inline]
34913#[target_feature(enable = "avx512f")]
34914#[stable(feature = "stdarch_x86_avx512", since = "1.89")]
34915#[rustc_const_unstable(feature = "stdarch_const_x86", issue = "149298")]
34916pub const fn _mm512_reduce_mul_pd(a: __m512d) -> f64 {
34917 unsafe {
34918 let a = _mm256_mul_pd(
34919 _mm512_extractf64x4_pd::<0>(a),
34920 _mm512_extractf64x4_pd::<1>(a),
34921 );
34922 let a = _mm_mul_pd(_mm256_extractf128_pd::<