1use crate::core_arch::x86::*;
22use crate::intrinsics::simd::{simd_fma, simd_neg};
23use crate::intrinsics::{fmaf32, fmaf64};
24
25#[cfg(test)]
26use stdarch_test::assert_instr;
27
28#[inline]
33#[target_feature(enable = "fma")]
34#[cfg_attr(test, assert_instr(vfmadd))]
35#[stable(feature = "simd_x86", since = "1.27.0")]
36pub unsafe fn _mm_fmadd_pd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
37    simd_fma(a, b, c)
38}
39
40#[inline]
45#[target_feature(enable = "fma")]
46#[cfg_attr(test, assert_instr(vfmadd))]
47#[stable(feature = "simd_x86", since = "1.27.0")]
48pub unsafe fn _mm256_fmadd_pd(a: __m256d, b: __m256d, c: __m256d) -> __m256d {
49    simd_fma(a, b, c)
50}
51
52#[inline]
57#[target_feature(enable = "fma")]
58#[cfg_attr(test, assert_instr(vfmadd))]
59#[stable(feature = "simd_x86", since = "1.27.0")]
60pub unsafe fn _mm_fmadd_ps(a: __m128, b: __m128, c: __m128) -> __m128 {
61    simd_fma(a, b, c)
62}
63
64#[inline]
69#[target_feature(enable = "fma")]
70#[cfg_attr(test, assert_instr(vfmadd))]
71#[stable(feature = "simd_x86", since = "1.27.0")]
72pub unsafe fn _mm256_fmadd_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
73    simd_fma(a, b, c)
74}
75
76#[inline]
83#[target_feature(enable = "fma")]
84#[cfg_attr(test, assert_instr(vfmadd))]
85#[stable(feature = "simd_x86", since = "1.27.0")]
86pub unsafe fn _mm_fmadd_sd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
87    simd_insert!(
88        a,
89        0,
90        fmaf64(_mm_cvtsd_f64(a), _mm_cvtsd_f64(b), _mm_cvtsd_f64(c))
91    )
92}
93
94#[inline]
101#[target_feature(enable = "fma")]
102#[cfg_attr(test, assert_instr(vfmadd))]
103#[stable(feature = "simd_x86", since = "1.27.0")]
104pub unsafe fn _mm_fmadd_ss(a: __m128, b: __m128, c: __m128) -> __m128 {
105    simd_insert!(
106        a,
107        0,
108        fmaf32(_mm_cvtss_f32(a), _mm_cvtss_f32(b), _mm_cvtss_f32(c))
109    )
110}
111
112#[inline]
118#[target_feature(enable = "fma")]
119#[cfg_attr(test, assert_instr(vfmaddsub))]
120#[stable(feature = "simd_x86", since = "1.27.0")]
121pub unsafe fn _mm_fmaddsub_pd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
122    let add = simd_fma(a, b, c);
123    let sub = simd_fma(a, b, simd_neg(c));
124    simd_shuffle!(add, sub, [2, 1])
125}
126
127#[inline]
133#[target_feature(enable = "fma")]
134#[cfg_attr(test, assert_instr(vfmaddsub))]
135#[stable(feature = "simd_x86", since = "1.27.0")]
136pub unsafe fn _mm256_fmaddsub_pd(a: __m256d, b: __m256d, c: __m256d) -> __m256d {
137    let add = simd_fma(a, b, c);
138    let sub = simd_fma(a, b, simd_neg(c));
139    simd_shuffle!(add, sub, [4, 1, 6, 3])
140}
141
142#[inline]
148#[target_feature(enable = "fma")]
149#[cfg_attr(test, assert_instr(vfmaddsub))]
150#[stable(feature = "simd_x86", since = "1.27.0")]
151pub unsafe fn _mm_fmaddsub_ps(a: __m128, b: __m128, c: __m128) -> __m128 {
152    let add = simd_fma(a, b, c);
153    let sub = simd_fma(a, b, simd_neg(c));
154    simd_shuffle!(add, sub, [4, 1, 6, 3])
155}
156
157#[inline]
163#[target_feature(enable = "fma")]
164#[cfg_attr(test, assert_instr(vfmaddsub))]
165#[stable(feature = "simd_x86", since = "1.27.0")]
166pub unsafe fn _mm256_fmaddsub_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
167    let add = simd_fma(a, b, c);
168    let sub = simd_fma(a, b, simd_neg(c));
169    simd_shuffle!(add, sub, [8, 1, 10, 3, 12, 5, 14, 7])
170}
171
172#[inline]
177#[target_feature(enable = "fma")]
178#[cfg_attr(test, assert_instr(vfmsub))]
179#[stable(feature = "simd_x86", since = "1.27.0")]
180pub unsafe fn _mm_fmsub_pd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
181    simd_fma(a, b, simd_neg(c))
182}
183
184#[inline]
189#[target_feature(enable = "fma")]
190#[cfg_attr(test, assert_instr(vfmsub))]
191#[stable(feature = "simd_x86", since = "1.27.0")]
192pub unsafe fn _mm256_fmsub_pd(a: __m256d, b: __m256d, c: __m256d) -> __m256d {
193    simd_fma(a, b, simd_neg(c))
194}
195
196#[inline]
201#[target_feature(enable = "fma")]
202#[cfg_attr(test, assert_instr(vfmsub213ps))]
203#[stable(feature = "simd_x86", since = "1.27.0")]
204pub unsafe fn _mm_fmsub_ps(a: __m128, b: __m128, c: __m128) -> __m128 {
205    simd_fma(a, b, simd_neg(c))
206}
207
208#[inline]
213#[target_feature(enable = "fma")]
214#[cfg_attr(test, assert_instr(vfmsub213ps))]
215#[stable(feature = "simd_x86", since = "1.27.0")]
216pub unsafe fn _mm256_fmsub_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
217    simd_fma(a, b, simd_neg(c))
218}
219
220#[inline]
227#[target_feature(enable = "fma")]
228#[cfg_attr(test, assert_instr(vfmsub))]
229#[stable(feature = "simd_x86", since = "1.27.0")]
230pub unsafe fn _mm_fmsub_sd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
231    simd_insert!(
232        a,
233        0,
234        fmaf64(_mm_cvtsd_f64(a), _mm_cvtsd_f64(b), -_mm_cvtsd_f64(c))
235    )
236}
237
238#[inline]
245#[target_feature(enable = "fma")]
246#[cfg_attr(test, assert_instr(vfmsub))]
247#[stable(feature = "simd_x86", since = "1.27.0")]
248pub unsafe fn _mm_fmsub_ss(a: __m128, b: __m128, c: __m128) -> __m128 {
249    simd_insert!(
250        a,
251        0,
252        fmaf32(_mm_cvtss_f32(a), _mm_cvtss_f32(b), -_mm_cvtss_f32(c))
253    )
254}
255
256#[inline]
262#[target_feature(enable = "fma")]
263#[cfg_attr(test, assert_instr(vfmsubadd))]
264#[stable(feature = "simd_x86", since = "1.27.0")]
265pub unsafe fn _mm_fmsubadd_pd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
266    let add = simd_fma(a, b, c);
267    let sub = simd_fma(a, b, simd_neg(c));
268    simd_shuffle!(add, sub, [0, 3])
269}
270
271#[inline]
277#[target_feature(enable = "fma")]
278#[cfg_attr(test, assert_instr(vfmsubadd))]
279#[stable(feature = "simd_x86", since = "1.27.0")]
280pub unsafe fn _mm256_fmsubadd_pd(a: __m256d, b: __m256d, c: __m256d) -> __m256d {
281    let add = simd_fma(a, b, c);
282    let sub = simd_fma(a, b, simd_neg(c));
283    simd_shuffle!(add, sub, [0, 5, 2, 7])
284}
285
286#[inline]
292#[target_feature(enable = "fma")]
293#[cfg_attr(test, assert_instr(vfmsubadd))]
294#[stable(feature = "simd_x86", since = "1.27.0")]
295pub unsafe fn _mm_fmsubadd_ps(a: __m128, b: __m128, c: __m128) -> __m128 {
296    let add = simd_fma(a, b, c);
297    let sub = simd_fma(a, b, simd_neg(c));
298    simd_shuffle!(add, sub, [0, 5, 2, 7])
299}
300
301#[inline]
307#[target_feature(enable = "fma")]
308#[cfg_attr(test, assert_instr(vfmsubadd))]
309#[stable(feature = "simd_x86", since = "1.27.0")]
310pub unsafe fn _mm256_fmsubadd_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
311    let add = simd_fma(a, b, c);
312    let sub = simd_fma(a, b, simd_neg(c));
313    simd_shuffle!(add, sub, [0, 9, 2, 11, 4, 13, 6, 15])
314}
315
316#[inline]
321#[target_feature(enable = "fma")]
322#[cfg_attr(test, assert_instr(vfnmadd))]
323#[stable(feature = "simd_x86", since = "1.27.0")]
324pub unsafe fn _mm_fnmadd_pd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
325    simd_fma(simd_neg(a), b, c)
326}
327
328#[inline]
333#[target_feature(enable = "fma")]
334#[cfg_attr(test, assert_instr(vfnmadd))]
335#[stable(feature = "simd_x86", since = "1.27.0")]
336pub unsafe fn _mm256_fnmadd_pd(a: __m256d, b: __m256d, c: __m256d) -> __m256d {
337    simd_fma(simd_neg(a), b, c)
338}
339
340#[inline]
345#[target_feature(enable = "fma")]
346#[cfg_attr(test, assert_instr(vfnmadd))]
347#[stable(feature = "simd_x86", since = "1.27.0")]
348pub unsafe fn _mm_fnmadd_ps(a: __m128, b: __m128, c: __m128) -> __m128 {
349    simd_fma(simd_neg(a), b, c)
350}
351
352#[inline]
357#[target_feature(enable = "fma")]
358#[cfg_attr(test, assert_instr(vfnmadd))]
359#[stable(feature = "simd_x86", since = "1.27.0")]
360pub unsafe fn _mm256_fnmadd_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
361    simd_fma(simd_neg(a), b, c)
362}
363
364#[inline]
371#[target_feature(enable = "fma")]
372#[cfg_attr(test, assert_instr(vfnmadd))]
373#[stable(feature = "simd_x86", since = "1.27.0")]
374pub unsafe fn _mm_fnmadd_sd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
375    simd_insert!(
376        a,
377        0,
378        fmaf64(_mm_cvtsd_f64(a), -_mm_cvtsd_f64(b), _mm_cvtsd_f64(c))
379    )
380}
381
382#[inline]
389#[target_feature(enable = "fma")]
390#[cfg_attr(test, assert_instr(vfnmadd))]
391#[stable(feature = "simd_x86", since = "1.27.0")]
392pub unsafe fn _mm_fnmadd_ss(a: __m128, b: __m128, c: __m128) -> __m128 {
393    simd_insert!(
394        a,
395        0,
396        fmaf32(_mm_cvtss_f32(a), -_mm_cvtss_f32(b), _mm_cvtss_f32(c))
397    )
398}
399
400#[inline]
406#[target_feature(enable = "fma")]
407#[cfg_attr(test, assert_instr(vfnmsub))]
408#[stable(feature = "simd_x86", since = "1.27.0")]
409pub unsafe fn _mm_fnmsub_pd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
410    simd_fma(simd_neg(a), b, simd_neg(c))
411}
412
413#[inline]
419#[target_feature(enable = "fma")]
420#[cfg_attr(test, assert_instr(vfnmsub))]
421#[stable(feature = "simd_x86", since = "1.27.0")]
422pub unsafe fn _mm256_fnmsub_pd(a: __m256d, b: __m256d, c: __m256d) -> __m256d {
423    simd_fma(simd_neg(a), b, simd_neg(c))
424}
425
426#[inline]
432#[target_feature(enable = "fma")]
433#[cfg_attr(test, assert_instr(vfnmsub))]
434#[stable(feature = "simd_x86", since = "1.27.0")]
435pub unsafe fn _mm_fnmsub_ps(a: __m128, b: __m128, c: __m128) -> __m128 {
436    simd_fma(simd_neg(a), b, simd_neg(c))
437}
438
439#[inline]
445#[target_feature(enable = "fma")]
446#[cfg_attr(test, assert_instr(vfnmsub))]
447#[stable(feature = "simd_x86", since = "1.27.0")]
448pub unsafe fn _mm256_fnmsub_ps(a: __m256, b: __m256, c: __m256) -> __m256 {
449    simd_fma(simd_neg(a), b, simd_neg(c))
450}
451
452#[inline]
460#[target_feature(enable = "fma")]
461#[cfg_attr(test, assert_instr(vfnmsub))]
462#[stable(feature = "simd_x86", since = "1.27.0")]
463pub unsafe fn _mm_fnmsub_sd(a: __m128d, b: __m128d, c: __m128d) -> __m128d {
464    simd_insert!(
465        a,
466        0,
467        fmaf64(_mm_cvtsd_f64(a), -_mm_cvtsd_f64(b), -_mm_cvtsd_f64(c))
468    )
469}
470
471#[inline]
479#[target_feature(enable = "fma")]
480#[cfg_attr(test, assert_instr(vfnmsub))]
481#[stable(feature = "simd_x86", since = "1.27.0")]
482pub unsafe fn _mm_fnmsub_ss(a: __m128, b: __m128, c: __m128) -> __m128 {
483    simd_insert!(
484        a,
485        0,
486        fmaf32(_mm_cvtss_f32(a), -_mm_cvtss_f32(b), -_mm_cvtss_f32(c))
487    )
488}
489
490#[cfg(test)]
491mod tests {
492
493    use stdarch_test::simd_test;
494
495    use crate::core_arch::x86::*;
496
497    #[simd_test(enable = "fma")]
498    unsafe fn test_mm_fmadd_pd() {
499        let a = _mm_setr_pd(1., 2.);
500        let b = _mm_setr_pd(5., 3.);
501        let c = _mm_setr_pd(4., 9.);
502        let r = _mm_setr_pd(9., 15.);
503        assert_eq_m128d(_mm_fmadd_pd(a, b, c), r);
504    }
505
506    #[simd_test(enable = "fma")]
507    unsafe fn test_mm256_fmadd_pd() {
508        let a = _mm256_setr_pd(1., 2., 3., 4.);
509        let b = _mm256_setr_pd(5., 3., 7., 2.);
510        let c = _mm256_setr_pd(4., 9., 1., 7.);
511        let r = _mm256_setr_pd(9., 15., 22., 15.);
512        assert_eq_m256d(_mm256_fmadd_pd(a, b, c), r);
513    }
514
515    #[simd_test(enable = "fma")]
516    unsafe fn test_mm_fmadd_ps() {
517        let a = _mm_setr_ps(1., 2., 3., 4.);
518        let b = _mm_setr_ps(5., 3., 7., 2.);
519        let c = _mm_setr_ps(4., 9., 1., 7.);
520        let r = _mm_setr_ps(9., 15., 22., 15.);
521        assert_eq_m128(_mm_fmadd_ps(a, b, c), r);
522    }
523
524    #[simd_test(enable = "fma")]
525    unsafe fn test_mm256_fmadd_ps() {
526        let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
527        let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
528        let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
529        let r = _mm256_setr_ps(9., 15., 22., 15., -5., -49., -2., -31.);
530        assert_eq_m256(_mm256_fmadd_ps(a, b, c), r);
531    }
532
533    #[simd_test(enable = "fma")]
534    unsafe fn test_mm_fmadd_sd() {
535        let a = _mm_setr_pd(1., 2.);
536        let b = _mm_setr_pd(5., 3.);
537        let c = _mm_setr_pd(4., 9.);
538        let r = _mm_setr_pd(9., 2.);
539        assert_eq_m128d(_mm_fmadd_sd(a, b, c), r);
540    }
541
542    #[simd_test(enable = "fma")]
543    unsafe fn test_mm_fmadd_ss() {
544        let a = _mm_setr_ps(1., 2., 3., 4.);
545        let b = _mm_setr_ps(5., 3., 7., 2.);
546        let c = _mm_setr_ps(4., 9., 1., 7.);
547        let r = _mm_setr_ps(9., 2., 3., 4.);
548        assert_eq_m128(_mm_fmadd_ss(a, b, c), r);
549    }
550
551    #[simd_test(enable = "fma")]
552    unsafe fn test_mm_fmaddsub_pd() {
553        let a = _mm_setr_pd(1., 2.);
554        let b = _mm_setr_pd(5., 3.);
555        let c = _mm_setr_pd(4., 9.);
556        let r = _mm_setr_pd(1., 15.);
557        assert_eq_m128d(_mm_fmaddsub_pd(a, b, c), r);
558    }
559
560    #[simd_test(enable = "fma")]
561    unsafe fn test_mm256_fmaddsub_pd() {
562        let a = _mm256_setr_pd(1., 2., 3., 4.);
563        let b = _mm256_setr_pd(5., 3., 7., 2.);
564        let c = _mm256_setr_pd(4., 9., 1., 7.);
565        let r = _mm256_setr_pd(1., 15., 20., 15.);
566        assert_eq_m256d(_mm256_fmaddsub_pd(a, b, c), r);
567    }
568
569    #[simd_test(enable = "fma")]
570    unsafe fn test_mm_fmaddsub_ps() {
571        let a = _mm_setr_ps(1., 2., 3., 4.);
572        let b = _mm_setr_ps(5., 3., 7., 2.);
573        let c = _mm_setr_ps(4., 9., 1., 7.);
574        let r = _mm_setr_ps(1., 15., 20., 15.);
575        assert_eq_m128(_mm_fmaddsub_ps(a, b, c), r);
576    }
577
578    #[simd_test(enable = "fma")]
579    unsafe fn test_mm256_fmaddsub_ps() {
580        let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
581        let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
582        let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
583        let r = _mm256_setr_ps(1., 15., 20., 15., 5., -49., 2., -31.);
584        assert_eq_m256(_mm256_fmaddsub_ps(a, b, c), r);
585    }
586
587    #[simd_test(enable = "fma")]
588    unsafe fn test_mm_fmsub_pd() {
589        let a = _mm_setr_pd(1., 2.);
590        let b = _mm_setr_pd(5., 3.);
591        let c = _mm_setr_pd(4., 9.);
592        let r = _mm_setr_pd(1., -3.);
593        assert_eq_m128d(_mm_fmsub_pd(a, b, c), r);
594    }
595
596    #[simd_test(enable = "fma")]
597    unsafe fn test_mm256_fmsub_pd() {
598        let a = _mm256_setr_pd(1., 2., 3., 4.);
599        let b = _mm256_setr_pd(5., 3., 7., 2.);
600        let c = _mm256_setr_pd(4., 9., 1., 7.);
601        let r = _mm256_setr_pd(1., -3., 20., 1.);
602        assert_eq_m256d(_mm256_fmsub_pd(a, b, c), r);
603    }
604
605    #[simd_test(enable = "fma")]
606    unsafe fn test_mm_fmsub_ps() {
607        let a = _mm_setr_ps(1., 2., 3., 4.);
608        let b = _mm_setr_ps(5., 3., 7., 2.);
609        let c = _mm_setr_ps(4., 9., 1., 7.);
610        let r = _mm_setr_ps(1., -3., 20., 1.);
611        assert_eq_m128(_mm_fmsub_ps(a, b, c), r);
612    }
613
614    #[simd_test(enable = "fma")]
615    unsafe fn test_mm256_fmsub_ps() {
616        let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
617        let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
618        let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
619        let r = _mm256_setr_ps(1., -3., 20., 1., 5., -71., 2., -25.);
620        assert_eq_m256(_mm256_fmsub_ps(a, b, c), r);
621    }
622
623    #[simd_test(enable = "fma")]
624    unsafe fn test_mm_fmsub_sd() {
625        let a = _mm_setr_pd(1., 2.);
626        let b = _mm_setr_pd(5., 3.);
627        let c = _mm_setr_pd(4., 9.);
628        let r = _mm_setr_pd(1., 2.);
629        assert_eq_m128d(_mm_fmsub_sd(a, b, c), r);
630    }
631
632    #[simd_test(enable = "fma")]
633    unsafe fn test_mm_fmsub_ss() {
634        let a = _mm_setr_ps(1., 2., 3., 4.);
635        let b = _mm_setr_ps(5., 3., 7., 2.);
636        let c = _mm_setr_ps(4., 9., 1., 7.);
637        let r = _mm_setr_ps(1., 2., 3., 4.);
638        assert_eq_m128(_mm_fmsub_ss(a, b, c), r);
639    }
640
641    #[simd_test(enable = "fma")]
642    unsafe fn test_mm_fmsubadd_pd() {
643        let a = _mm_setr_pd(1., 2.);
644        let b = _mm_setr_pd(5., 3.);
645        let c = _mm_setr_pd(4., 9.);
646        let r = _mm_setr_pd(9., -3.);
647        assert_eq_m128d(_mm_fmsubadd_pd(a, b, c), r);
648    }
649
650    #[simd_test(enable = "fma")]
651    unsafe fn test_mm256_fmsubadd_pd() {
652        let a = _mm256_setr_pd(1., 2., 3., 4.);
653        let b = _mm256_setr_pd(5., 3., 7., 2.);
654        let c = _mm256_setr_pd(4., 9., 1., 7.);
655        let r = _mm256_setr_pd(9., -3., 22., 1.);
656        assert_eq_m256d(_mm256_fmsubadd_pd(a, b, c), r);
657    }
658
659    #[simd_test(enable = "fma")]
660    unsafe fn test_mm_fmsubadd_ps() {
661        let a = _mm_setr_ps(1., 2., 3., 4.);
662        let b = _mm_setr_ps(5., 3., 7., 2.);
663        let c = _mm_setr_ps(4., 9., 1., 7.);
664        let r = _mm_setr_ps(9., -3., 22., 1.);
665        assert_eq_m128(_mm_fmsubadd_ps(a, b, c), r);
666    }
667
668    #[simd_test(enable = "fma")]
669    unsafe fn test_mm256_fmsubadd_ps() {
670        let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
671        let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
672        let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
673        let r = _mm256_setr_ps(9., -3., 22., 1., -5., -71., -2., -25.);
674        assert_eq_m256(_mm256_fmsubadd_ps(a, b, c), r);
675    }
676
677    #[simd_test(enable = "fma")]
678    unsafe fn test_mm_fnmadd_pd() {
679        let a = _mm_setr_pd(1., 2.);
680        let b = _mm_setr_pd(5., 3.);
681        let c = _mm_setr_pd(4., 9.);
682        let r = _mm_setr_pd(-1., 3.);
683        assert_eq_m128d(_mm_fnmadd_pd(a, b, c), r);
684    }
685
686    #[simd_test(enable = "fma")]
687    unsafe fn test_mm256_fnmadd_pd() {
688        let a = _mm256_setr_pd(1., 2., 3., 4.);
689        let b = _mm256_setr_pd(5., 3., 7., 2.);
690        let c = _mm256_setr_pd(4., 9., 1., 7.);
691        let r = _mm256_setr_pd(-1., 3., -20., -1.);
692        assert_eq_m256d(_mm256_fnmadd_pd(a, b, c), r);
693    }
694
695    #[simd_test(enable = "fma")]
696    unsafe fn test_mm_fnmadd_ps() {
697        let a = _mm_setr_ps(1., 2., 3., 4.);
698        let b = _mm_setr_ps(5., 3., 7., 2.);
699        let c = _mm_setr_ps(4., 9., 1., 7.);
700        let r = _mm_setr_ps(-1., 3., -20., -1.);
701        assert_eq_m128(_mm_fnmadd_ps(a, b, c), r);
702    }
703
704    #[simd_test(enable = "fma")]
705    unsafe fn test_mm256_fnmadd_ps() {
706        let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
707        let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
708        let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
709        let r = _mm256_setr_ps(-1., 3., -20., -1., -5., 71., -2., 25.);
710        assert_eq_m256(_mm256_fnmadd_ps(a, b, c), r);
711    }
712
713    #[simd_test(enable = "fma")]
714    unsafe fn test_mm_fnmadd_sd() {
715        let a = _mm_setr_pd(1., 2.);
716        let b = _mm_setr_pd(5., 3.);
717        let c = _mm_setr_pd(4., 9.);
718        let r = _mm_setr_pd(-1., 2.);
719        assert_eq_m128d(_mm_fnmadd_sd(a, b, c), r);
720    }
721
722    #[simd_test(enable = "fma")]
723    unsafe fn test_mm_fnmadd_ss() {
724        let a = _mm_setr_ps(1., 2., 3., 4.);
725        let b = _mm_setr_ps(5., 3., 7., 2.);
726        let c = _mm_setr_ps(4., 9., 1., 7.);
727        let r = _mm_setr_ps(-1., 2., 3., 4.);
728        assert_eq_m128(_mm_fnmadd_ss(a, b, c), r);
729    }
730
731    #[simd_test(enable = "fma")]
732    unsafe fn test_mm_fnmsub_pd() {
733        let a = _mm_setr_pd(1., 2.);
734        let b = _mm_setr_pd(5., 3.);
735        let c = _mm_setr_pd(4., 9.);
736        let r = _mm_setr_pd(-9., -15.);
737        assert_eq_m128d(_mm_fnmsub_pd(a, b, c), r);
738    }
739
740    #[simd_test(enable = "fma")]
741    unsafe fn test_mm256_fnmsub_pd() {
742        let a = _mm256_setr_pd(1., 2., 3., 4.);
743        let b = _mm256_setr_pd(5., 3., 7., 2.);
744        let c = _mm256_setr_pd(4., 9., 1., 7.);
745        let r = _mm256_setr_pd(-9., -15., -22., -15.);
746        assert_eq_m256d(_mm256_fnmsub_pd(a, b, c), r);
747    }
748
749    #[simd_test(enable = "fma")]
750    unsafe fn test_mm_fnmsub_ps() {
751        let a = _mm_setr_ps(1., 2., 3., 4.);
752        let b = _mm_setr_ps(5., 3., 7., 2.);
753        let c = _mm_setr_ps(4., 9., 1., 7.);
754        let r = _mm_setr_ps(-9., -15., -22., -15.);
755        assert_eq_m128(_mm_fnmsub_ps(a, b, c), r);
756    }
757
758    #[simd_test(enable = "fma")]
759    unsafe fn test_mm256_fnmsub_ps() {
760        let a = _mm256_setr_ps(1., 2., 3., 4., 0., 10., -1., -2.);
761        let b = _mm256_setr_ps(5., 3., 7., 2., 4., -6., 0., 14.);
762        let c = _mm256_setr_ps(4., 9., 1., 7., -5., 11., -2., -3.);
763        let r = _mm256_setr_ps(-9., -15., -22., -15., 5., 49., 2., 31.);
764        assert_eq_m256(_mm256_fnmsub_ps(a, b, c), r);
765    }
766
767    #[simd_test(enable = "fma")]
768    unsafe fn test_mm_fnmsub_sd() {
769        let a = _mm_setr_pd(1., 2.);
770        let b = _mm_setr_pd(5., 3.);
771        let c = _mm_setr_pd(4., 9.);
772        let r = _mm_setr_pd(-9., 2.);
773        assert_eq_m128d(_mm_fnmsub_sd(a, b, c), r);
774    }
775
776    #[simd_test(enable = "fma")]
777    unsafe fn test_mm_fnmsub_ss() {
778        let a = _mm_setr_ps(1., 2., 3., 4.);
779        let b = _mm_setr_ps(5., 3., 7., 2.);
780        let c = _mm_setr_ps(4., 9., 1., 7.);
781        let r = _mm_setr_ps(-9., 2., 3., 4.);
782        assert_eq_m128(_mm_fnmsub_ss(a, b, c), r);
783    }
784}