11#ifndef EIGEN_PACKET_MATH_SSE_H
12#define EIGEN_PACKET_MATH_SSE_H
16#include "../../InternalHeaderCheck.h"
22#ifndef EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD
23#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD 8
26#if !defined(EIGEN_VECTORIZE_AVX) && !defined(EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS)
29#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS (2 * sizeof(void*))
32#ifdef EIGEN_VECTORIZE_FMA
33#ifndef EIGEN_HAS_SINGLE_INSTRUCTION_MADD
34#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
38#if ((defined EIGEN_VECTORIZE_AVX) && (EIGEN_COMP_GNUC_STRICT || EIGEN_COMP_MINGW || EIGEN_COMP_LCC) && \
39 (__GXX_ABI_VERSION < 1004)) || \
46using Packet4f = eigen_packet_wrapper<__m128>;
47using Packet2d = eigen_packet_wrapper<__m128d>;
49using Packet4f = __m128;
50using Packet2d = __m128d;
53using Packet4i = eigen_packet_wrapper<__m128i, 0>;
54using Packet16b = eigen_packet_wrapper<__m128i, 1>;
55using Packet4ui = eigen_packet_wrapper<__m128i, 4>;
56using Packet2l = eigen_packet_wrapper<__m128i, 5>;
59struct is_arithmetic<__m128> : std::true_type {};
61struct is_arithmetic<__m128i> : std::true_type {};
63struct is_arithmetic<__m128d> : std::true_type {};
65struct is_arithmetic<Packet4i> : std::true_type {};
67struct is_arithmetic<Packet2l> : std::true_type {};
72struct is_arithmetic<Packet4ui> : std::false_type {};
74struct is_arithmetic<Packet16b> : std::true_type {};
76template <
int p,
int q,
int r,
int s>
78 enum { mask = (s) << 6 | (r) << 4 | (q) << 2 | (p) };
81#define SIGN_MASK_I32 static_cast<int32_t>(0x80000000)
84#define vec4f_swizzle1(v, p, q, r, s) \
85 Packet4f(_mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(v), (shuffle_mask<p, q, r, s>::mask))))
87#define vec4i_swizzle1(v, p, q, r, s) Packet4i(_mm_shuffle_epi32(v, (shuffle_mask<p, q, r, s>::mask)))
89#define vec4ui_swizzle1(v, p, q, r, s) Packet4ui(vec4i_swizzle1(v, p, q, r, s))
91#define vec2d_swizzle1(v, p, q) \
92 Packet2d(_mm_castsi128_pd( \
93 _mm_shuffle_epi32(_mm_castpd_si128(v), (shuffle_mask<2 * p, 2 * p + 1, 2 * q, 2 * q + 1>::mask))))
95#define vec4f_swizzle2(a, b, p, q, r, s) Packet4f(_mm_shuffle_ps((a), (b), (shuffle_mask<p, q, r, s>::mask)))
97#define vec4i_swizzle2(a, b, p, q, r, s) \
99 _mm_castps_si128((_mm_shuffle_ps(_mm_castsi128_ps(a), _mm_castsi128_ps(b), (shuffle_mask<p, q, r, s>::mask)))))
101#define vec4ui_swizzle2(a, b, p, q, r, s) Packet4i(vec4i_swizzle2(a, b, p, q, r, s))
103EIGEN_STRONG_INLINE Packet4f vec4f_movelh(
const Packet4f& a,
const Packet4f& b) {
104 return Packet4f(_mm_movelh_ps(a, b));
106EIGEN_STRONG_INLINE Packet4f vec4f_movehl(
const Packet4f& a,
const Packet4f& b) {
107 return Packet4f(_mm_movehl_ps(a, b));
109EIGEN_STRONG_INLINE Packet4f vec4f_unpacklo(
const Packet4f& a,
const Packet4f& b) {
110 return Packet4f(_mm_unpacklo_ps(a, b));
112EIGEN_STRONG_INLINE Packet4f vec4f_unpackhi(
const Packet4f& a,
const Packet4f& b) {
113 return Packet4f(_mm_unpackhi_ps(a, b));
115#define vec4f_duplane(a, p) vec4f_swizzle2(a, a, p, p, p, p)
117#define vec2d_swizzle2(a, b, mask) Packet2d(_mm_shuffle_pd(a, b, mask))
119EIGEN_STRONG_INLINE Packet2d vec2d_unpacklo(
const Packet2d& a,
const Packet2d& b) {
120 return Packet2d(_mm_unpacklo_pd(a, b));
122EIGEN_STRONG_INLINE Packet2d vec2d_unpackhi(
const Packet2d& a,
const Packet2d& b) {
123 return Packet2d(_mm_unpackhi_pd(a, b));
125#define vec2d_duplane(a, p) vec2d_swizzle2(a, a, (p << 1) | p)
127#define EIGEN_DECLARE_CONST_Packet4f(NAME, X) const Packet4f p4f_##NAME = pset1<Packet4f>(X)
129#define EIGEN_DECLARE_CONST_Packet2d(NAME, X) const Packet2d p2d_##NAME = pset1<Packet2d>(X)
131#define EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME, X) const Packet4f p4f_##NAME = pset1frombits<Packet4f>(X)
133#define EIGEN_DECLARE_CONST_Packet4i(NAME, X) const Packet4i p4i_##NAME = pset1<Packet4i>(X)
135#define EIGEN_DECLARE_CONST_Packet4ui(NAME, X) const Packet4ui p4ui_##NAME = pset1<Packet4ui>(X)
139EIGEN_ALWAYS_INLINE int64_t _mm_extract_epi64_0(
const __m128i& a) {
return _mm_cvtsi128_si64(a); }
140#ifdef EIGEN_VECTORIZE_SSE4_1
141EIGEN_ALWAYS_INLINE int64_t _mm_extract_epi64_1(
const __m128i& a) {
return _mm_extract_epi64(a, 1); }
143EIGEN_ALWAYS_INLINE int64_t _mm_extract_epi64_1(
const __m128i& a) {
144 return _mm_cvtsi128_si64(_mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd(a), _mm_castsi128_pd(a), 0x1)));
150EIGEN_ALWAYS_INLINE int64_t _mm_extract_epi64_0(
const __m128i& a) {
151 return numext::bit_cast<int64_t>(_mm_cvtsd_f64(_mm_castsi128_pd(a)));
153EIGEN_ALWAYS_INLINE int64_t _mm_extract_epi64_1(
const __m128i& a) {
154 return numext::bit_cast<int64_t>(_mm_cvtsd_f64(_mm_shuffle_pd(_mm_castsi128_pd(a), _mm_castsi128_pd(a), 0x1)));
160#ifndef EIGEN_VECTORIZE_AVX
162struct packet_traits<float> : default_packet_traits {
163 using type = Packet4f;
164 using half = Packet4f;
172 HasReciprocal = EIGEN_FAST_MATH,
173 HasSin = EIGEN_FAST_MATH,
174 HasCos = EIGEN_FAST_MATH,
175 HasTan = EIGEN_FAST_MATH,
195 HasTanh = EIGEN_FAST_MATH,
196 HasErf = EIGEN_FAST_MATH,
197 HasErfc = EIGEN_FAST_MATH,
202struct packet_traits<double> : default_packet_traits {
203 using type = Packet2d;
204 using half = Packet2d;
212 HasSin = EIGEN_FAST_MATH,
213 HasCos = EIGEN_FAST_MATH,
214 HasTan = EIGEN_FAST_MATH,
219 HasTanh = EIGEN_FAST_MATH,
220 HasErf = EIGEN_FAST_MATH,
221 HasErfc = EIGEN_FAST_MATH,
236struct packet_traits<int> : default_packet_traits {
237 using type = Packet4i;
238 using half = Packet4i;
251struct packet_traits<uint32_t> : default_packet_traits {
252 using type = Packet4ui;
253 using half = Packet4ui;
266struct packet_traits<int64_t> : default_packet_traits {
267 using type = Packet2l;
268 using half = Packet2l;
280struct packet_traits<bool> : default_packet_traits {
281 using type = Packet16b;
282 using half = Packet16b;
301struct unpacket_traits<Packet4f> {
303 using half = Packet4f;
304 using integer_packet = Packet4i;
309 masked_load_available =
false,
310 masked_store_available =
false
314struct unpacket_traits<Packet2d> {
316 using half = Packet2d;
317 using integer_packet = Packet2l;
322 masked_load_available =
false,
323 masked_store_available =
false
327struct unpacket_traits<Packet2l> {
328 using type = int64_t;
329 using half = Packet2l;
334 masked_load_available =
false,
335 masked_store_available =
false
339struct unpacket_traits<Packet4i> {
341 using half = Packet4i;
346 masked_load_available =
false,
347 masked_store_available =
false
351struct unpacket_traits<Packet4ui> {
352 using type = uint32_t;
353 using half = Packet4ui;
358 masked_load_available =
false,
359 masked_store_available =
false
363struct unpacket_traits<Packet16b> {
365 using half = Packet16b;
370 masked_load_available =
false,
371 masked_store_available =
false
375#ifndef EIGEN_VECTORIZE_AVX
377struct scalar_div_cost<float, true> : std::integral_constant<int, 7> {};
379struct scalar_div_cost<double, true> : std::integral_constant<int, 8> {};
383EIGEN_STRONG_INLINE Packet4f pset1<Packet4f>(
const float& from) {
384 return _mm_set_ps1(from);
387EIGEN_STRONG_INLINE Packet2d pset1<Packet2d>(
const double& from) {
388 return _mm_set1_pd(from);
391EIGEN_STRONG_INLINE Packet2l pset1<Packet2l>(
const int64_t& from) {
392 return _mm_set1_epi64x(from);
395EIGEN_STRONG_INLINE Packet4i pset1<Packet4i>(
const int& from) {
396 return _mm_set1_epi32(from);
399EIGEN_STRONG_INLINE Packet4ui pset1<Packet4ui>(
const uint32_t& from) {
400 return _mm_set1_epi32(numext::bit_cast<int32_t>(from));
403EIGEN_STRONG_INLINE Packet16b pset1<Packet16b>(
const bool& from) {
404 return _mm_set1_epi8(
static_cast<char>(from));
408EIGEN_STRONG_INLINE Packet4f pset1frombits<Packet4f>(
unsigned int from) {
409 return _mm_castsi128_ps(pset1<Packet4i>(from));
412EIGEN_STRONG_INLINE Packet2d pset1frombits<Packet2d>(uint64_t from) {
413 return _mm_castsi128_pd(_mm_set1_epi64x(from));
417EIGEN_STRONG_INLINE Packet4f peven_mask(
const Packet4f& ) {
418 Packet4f r = _mm_castsi128_ps(_mm_set_epi32(0, -1, 0, -1));
419 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
423EIGEN_STRONG_INLINE Packet2l peven_mask(
const Packet2l& ) {
424 return _mm_set_epi32(0, 0, -1, -1);
427EIGEN_STRONG_INLINE Packet4i peven_mask(
const Packet4i& ) {
428 return _mm_set_epi32(0, -1, 0, -1);
431EIGEN_STRONG_INLINE Packet4ui peven_mask(
const Packet4ui& ) {
432 return _mm_set_epi32(0, -1, 0, -1);
435EIGEN_STRONG_INLINE Packet2d peven_mask(
const Packet2d& ) {
436 Packet2d r = _mm_castsi128_pd(_mm_set_epi32(0, 0, -1, -1));
437 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
442EIGEN_STRONG_INLINE Packet4f pzero(
const Packet4f& ) {
443 return _mm_setzero_ps();
446EIGEN_STRONG_INLINE Packet2d pzero(
const Packet2d& ) {
447 return _mm_setzero_pd();
450EIGEN_STRONG_INLINE Packet2l pzero(
const Packet2l& ) {
451 return _mm_setzero_si128();
454EIGEN_STRONG_INLINE Packet4i pzero(
const Packet4i& ) {
455 return _mm_setzero_si128();
458EIGEN_STRONG_INLINE Packet4ui pzero(
const Packet4ui& ) {
459 return _mm_setzero_si128();
467#if EIGEN_COMP_GNUC_STRICT && (!defined __AVX__)
469EIGEN_STRONG_INLINE Packet4f pload1<Packet4f>(
const float* from) {
470 return vec4f_swizzle1(_mm_load_ss(from), 0, 0, 0, 0);
475EIGEN_STRONG_INLINE Packet4f plset<Packet4f>(
const float& a) {
476 return _mm_add_ps(pset1<Packet4f>(a), _mm_set_ps(3, 2, 1, 0));
479EIGEN_STRONG_INLINE Packet2d plset<Packet2d>(
const double& a) {
480 return _mm_add_pd(pset1<Packet2d>(a), _mm_set_pd(1, 0));
483EIGEN_STRONG_INLINE Packet2l plset<Packet2l>(
const int64_t& a) {
484 return _mm_add_epi64(pset1<Packet2l>(a), _mm_set_epi64x(1, 0));
487EIGEN_STRONG_INLINE Packet4i plset<Packet4i>(
const int& a) {
488 return _mm_add_epi32(pset1<Packet4i>(a), _mm_set_epi32(3, 2, 1, 0));
491EIGEN_STRONG_INLINE Packet4ui plset<Packet4ui>(
const uint32_t& a) {
492 return _mm_add_epi32(pset1<Packet4ui>(a), _mm_set_epi32(3, 2, 1, 0));
496EIGEN_STRONG_INLINE Packet4f padd<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
497 return _mm_add_ps(a, b);
500EIGEN_STRONG_INLINE Packet2d padd<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
501 return _mm_add_pd(a, b);
504EIGEN_STRONG_INLINE Packet2l padd<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
505 return _mm_add_epi64(a, b);
508EIGEN_STRONG_INLINE Packet4i padd<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
509 return _mm_add_epi32(a, b);
512EIGEN_STRONG_INLINE Packet4ui padd<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
513 return _mm_add_epi32(a, b);
517EIGEN_STRONG_INLINE Packet16b padd<Packet16b>(
const Packet16b& a,
const Packet16b& b) {
518 return _mm_or_si128(a, b);
521template <
typename Packet>
522EIGEN_STRONG_INLINE Packet padds(
const Packet& a,
const Packet& b);
524EIGEN_STRONG_INLINE Packet4f padds<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
525 return _mm_add_ss(a, b);
528EIGEN_STRONG_INLINE Packet2d padds<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
529 return _mm_add_sd(a, b);
533EIGEN_STRONG_INLINE Packet4f psub<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
534 return _mm_sub_ps(a, b);
537EIGEN_STRONG_INLINE Packet2d psub<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
538 return _mm_sub_pd(a, b);
541EIGEN_STRONG_INLINE Packet2l psub<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
542 return _mm_sub_epi64(a, b);
545EIGEN_STRONG_INLINE Packet4i psub<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
546 return _mm_sub_epi32(a, b);
549EIGEN_STRONG_INLINE Packet4ui psub<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
550 return _mm_sub_epi32(a, b);
553EIGEN_STRONG_INLINE Packet16b psub<Packet16b>(
const Packet16b& a,
const Packet16b& b) {
554 return _mm_xor_si128(a, b);
558EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(
const Packet4f& a,
const Packet4f& b);
560EIGEN_STRONG_INLINE Packet4f paddsub<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
561#ifdef EIGEN_VECTORIZE_SSE3
562 return _mm_addsub_ps(a, b);
564 const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(SIGN_MASK_I32, 0x0, SIGN_MASK_I32, 0x0));
565 return padd(a, pxor(mask, b));
570EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(
const Packet2d&,
const Packet2d&);
572EIGEN_STRONG_INLINE Packet2d paddsub<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
573#ifdef EIGEN_VECTORIZE_SSE3
574 return _mm_addsub_pd(a, b);
576 const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0, SIGN_MASK_I32, 0x0, 0x0));
577 return padd(a, pxor(mask, b));
582EIGEN_STRONG_INLINE Packet4f pnegate(
const Packet4f& a) {
583 const Packet4f mask = _mm_castsi128_ps(_mm_setr_epi32(SIGN_MASK_I32, SIGN_MASK_I32, SIGN_MASK_I32, SIGN_MASK_I32));
584 return _mm_xor_ps(a, mask);
587EIGEN_STRONG_INLINE Packet2d pnegate(
const Packet2d& a) {
588 const Packet2d mask = _mm_castsi128_pd(_mm_setr_epi32(0x0, SIGN_MASK_I32, 0x0, SIGN_MASK_I32));
589 return _mm_xor_pd(a, mask);
592EIGEN_STRONG_INLINE Packet2l pnegate(
const Packet2l& a) {
593 return psub(pzero(a), a);
597EIGEN_STRONG_INLINE Packet4i pnegate(
const Packet4i& a) {
598 return psub(pzero(a), a);
602EIGEN_STRONG_INLINE Packet4f pmul<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
603 return _mm_mul_ps(a, b);
606EIGEN_STRONG_INLINE Packet2d pmul<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
607 return _mm_mul_pd(a, b);
610EIGEN_STRONG_INLINE Packet2l pmul<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
612 __m128i upper32_a = _mm_srli_epi64(a, 32);
613 __m128i upper32_b = _mm_srli_epi64(b, 32);
616 __m128i mul1 = _mm_mul_epu32(upper32_a, b);
617 __m128i mul2 = _mm_mul_epu32(upper32_b, a);
619 __m128i mul3 = _mm_mul_epu32(a, b);
621 __m128i high = _mm_slli_epi64(_mm_add_epi64(mul1, mul2), 32);
622 return _mm_add_epi64(high, mul3);
625EIGEN_STRONG_INLINE Packet4i pmul<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
626#ifdef EIGEN_VECTORIZE_SSE4_1
627 return _mm_mullo_epi32(a, b);
630 return vec4i_swizzle1(
631 vec4i_swizzle2(_mm_mul_epu32(a, b), _mm_mul_epu32(vec4i_swizzle1(a, 1, 0, 3, 2), vec4i_swizzle1(b, 1, 0, 3, 2)),
637EIGEN_STRONG_INLINE Packet4ui pmul<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
638#ifdef EIGEN_VECTORIZE_SSE4_1
639 return _mm_mullo_epi32(a, b);
642 return vec4ui_swizzle1(
643 vec4ui_swizzle2(_mm_mul_epu32(a, b),
644 _mm_mul_epu32(vec4ui_swizzle1(a, 1, 0, 3, 2), vec4ui_swizzle1(b, 1, 0, 3, 2)), 0, 2, 0, 2),
650EIGEN_STRONG_INLINE Packet16b pmul<Packet16b>(
const Packet16b& a,
const Packet16b& b) {
651 return _mm_and_si128(a, b);
655EIGEN_STRONG_INLINE Packet4f pdiv<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
656 return _mm_div_ps(a, b);
659EIGEN_STRONG_INLINE Packet2d pdiv<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
660 return _mm_div_pd(a, b);
664EIGEN_STRONG_INLINE Packet4i pdiv<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
665#ifdef EIGEN_VECTORIZE_AVX
666 return _mm256_cvttpd_epi32(_mm256_div_pd(_mm256_cvtepi32_pd(a), _mm256_cvtepi32_pd(b)));
668 __m128i q_lo = _mm_cvttpd_epi32(_mm_div_pd(_mm_cvtepi32_pd(a), _mm_cvtepi32_pd(b)));
669 __m128i q_hi = _mm_cvttpd_epi32(
670 _mm_div_pd(_mm_cvtepi32_pd(vec4i_swizzle1(a, 2, 3, 0, 1)), _mm_cvtepi32_pd(vec4i_swizzle1(b, 2, 3, 0, 1))));
671 return vec4i_swizzle1(_mm_unpacklo_epi32(q_lo, q_hi), 0, 2, 1, 3);
675#ifdef EIGEN_VECTORIZE_FMA
677struct is_fused_madd<Packet4f> : true_type {};
679EIGEN_STRONG_INLINE Packet4f pmadd(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
680 return _mm_fmadd_ps(a, b, c);
683struct is_fused_madd<Packet2d> : true_type {};
685EIGEN_STRONG_INLINE Packet2d pmadd(
const Packet2d& a,
const Packet2d& b,
const Packet2d& c) {
686 return _mm_fmadd_pd(a, b, c);
689EIGEN_STRONG_INLINE Packet4f pmsub(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
690 return _mm_fmsub_ps(a, b, c);
693EIGEN_STRONG_INLINE Packet2d pmsub(
const Packet2d& a,
const Packet2d& b,
const Packet2d& c) {
694 return _mm_fmsub_pd(a, b, c);
697EIGEN_STRONG_INLINE Packet4f pnmadd(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
698 return _mm_fnmadd_ps(a, b, c);
701EIGEN_STRONG_INLINE Packet2d pnmadd(
const Packet2d& a,
const Packet2d& b,
const Packet2d& c) {
702 return _mm_fnmadd_pd(a, b, c);
705EIGEN_STRONG_INLINE Packet4f pnmsub(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
706 return _mm_fnmsub_ps(a, b, c);
709EIGEN_STRONG_INLINE Packet2d pnmsub(
const Packet2d& a,
const Packet2d& b,
const Packet2d& c) {
710 return _mm_fnmsub_pd(a, b, c);
713template <
typename Packet>
714EIGEN_STRONG_INLINE Packet pmadds(
const Packet& a,
const Packet& b,
const Packet& c);
716EIGEN_STRONG_INLINE Packet4f pmadds<Packet4f>(
const Packet4f& a,
const Packet4f& b,
const Packet4f& c) {
717 return _mm_fmadd_ss(a, b, c);
720EIGEN_STRONG_INLINE Packet2d pmadds<Packet2d>(
const Packet2d& a,
const Packet2d& b,
const Packet2d& c) {
721 return _mm_fmadd_sd(a, b, c);
725#ifdef EIGEN_VECTORIZE_SSE4_1
727EIGEN_STRONG_INLINE Packet4f pselect(
const Packet4f& mask,
const Packet4f& a,
const Packet4f& b) {
728 return _mm_blendv_ps(b, a, mask);
732EIGEN_STRONG_INLINE Packet2l pselect(
const Packet2l& mask,
const Packet2l& a,
const Packet2l& b) {
733 return _mm_castpd_si128(_mm_blendv_pd(_mm_castsi128_pd(b), _mm_castsi128_pd(a), _mm_castsi128_pd(mask)));
737EIGEN_STRONG_INLINE Packet4i pselect(
const Packet4i& mask,
const Packet4i& a,
const Packet4i& b) {
738 return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(b), _mm_castsi128_ps(a), _mm_castsi128_ps(mask)));
742EIGEN_STRONG_INLINE Packet4ui pselect(
const Packet4ui& mask,
const Packet4ui& a,
const Packet4ui& b) {
743 return _mm_castps_si128(_mm_blendv_ps(_mm_castsi128_ps(b), _mm_castsi128_ps(a), _mm_castsi128_ps(mask)));
747EIGEN_STRONG_INLINE Packet2d pselect(
const Packet2d& mask,
const Packet2d& a,
const Packet2d& b) {
748 return _mm_blendv_pd(b, a, mask);
753EIGEN_STRONG_INLINE Packet2l ptrue<Packet2l>(
const Packet2l& a) {
754 return _mm_cmpeq_epi32(a, a);
757EIGEN_STRONG_INLINE Packet4i ptrue<Packet4i>(
const Packet4i& a) {
758 return _mm_cmpeq_epi32(a, a);
761EIGEN_STRONG_INLINE Packet16b ptrue<Packet16b>(
const Packet16b& ) {
762 return pset1<Packet16b>(
true);
765EIGEN_STRONG_INLINE Packet4f ptrue<Packet4f>(
const Packet4f& a) {
766 Packet4i b = _mm_castps_si128(a);
767 Packet4f r = _mm_castsi128_ps(_mm_cmpeq_epi32(b, b));
768 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
772EIGEN_STRONG_INLINE Packet2d ptrue<Packet2d>(
const Packet2d& a) {
773 Packet4i b = _mm_castpd_si128(a);
774 Packet2d r = _mm_castsi128_pd(_mm_cmpeq_epi32(b, b));
775 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
780EIGEN_STRONG_INLINE Packet4f pand<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
781 return _mm_and_ps(a, b);
784EIGEN_STRONG_INLINE Packet2d pand<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
785 return _mm_and_pd(a, b);
788EIGEN_STRONG_INLINE Packet2l pand<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
789 return _mm_and_si128(a, b);
792EIGEN_STRONG_INLINE Packet4i pand<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
793 return _mm_and_si128(a, b);
796EIGEN_STRONG_INLINE Packet4ui pand<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
797 return _mm_and_si128(a, b);
800EIGEN_STRONG_INLINE Packet16b pand<Packet16b>(
const Packet16b& a,
const Packet16b& b) {
801 return _mm_and_si128(a, b);
805EIGEN_STRONG_INLINE Packet4f por<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
806 return _mm_or_ps(a, b);
809EIGEN_STRONG_INLINE Packet2d por<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
810 return _mm_or_pd(a, b);
813EIGEN_STRONG_INLINE Packet2l por<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
814 return _mm_or_si128(a, b);
817EIGEN_STRONG_INLINE Packet4i por<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
818 return _mm_or_si128(a, b);
821EIGEN_STRONG_INLINE Packet4ui por<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
822 return _mm_or_si128(a, b);
825EIGEN_STRONG_INLINE Packet16b por<Packet16b>(
const Packet16b& a,
const Packet16b& b) {
826 return _mm_or_si128(a, b);
830EIGEN_STRONG_INLINE Packet4f pxor<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
831 return _mm_xor_ps(a, b);
834EIGEN_STRONG_INLINE Packet2d pxor<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
835 return _mm_xor_pd(a, b);
838EIGEN_STRONG_INLINE Packet2l pxor<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
839 return _mm_xor_si128(a, b);
842EIGEN_STRONG_INLINE Packet4i pxor<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
843 return _mm_xor_si128(a, b);
846EIGEN_STRONG_INLINE Packet4ui pxor<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
847 return _mm_xor_si128(a, b);
850EIGEN_STRONG_INLINE Packet16b pxor<Packet16b>(
const Packet16b& a,
const Packet16b& b) {
851 return _mm_xor_si128(a, b);
855EIGEN_STRONG_INLINE Packet4f pandnot<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
856 return _mm_andnot_ps(b, a);
859EIGEN_STRONG_INLINE Packet2d pandnot<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
860 return _mm_andnot_pd(b, a);
863EIGEN_STRONG_INLINE Packet2l pandnot<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
864 return _mm_andnot_si128(b, a);
867EIGEN_STRONG_INLINE Packet4i pandnot<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
868 return _mm_andnot_si128(b, a);
871EIGEN_STRONG_INLINE Packet4ui pandnot<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
872 return _mm_andnot_si128(b, a);
875EIGEN_STRONG_INLINE Packet16b pandnot<Packet16b>(
const Packet16b& a,
const Packet16b& b) {
876 return _mm_andnot_si128(b, a);
879EIGEN_STRONG_INLINE Packet16b pcmp_lt(
const Packet16b& a,
const Packet16b& b) {
880 return _mm_andnot_si128(a, b);
883EIGEN_STRONG_INLINE Packet4f pcmp_le(
const Packet4f& a,
const Packet4f& b) {
884 return _mm_cmple_ps(a, b);
887EIGEN_STRONG_INLINE Packet4f pcmp_lt(
const Packet4f& a,
const Packet4f& b) {
888 return _mm_cmplt_ps(a, b);
891EIGEN_STRONG_INLINE Packet4f pcmp_lt_or_nan(
const Packet4f& a,
const Packet4f& b) {
892 return _mm_cmpnge_ps(a, b);
895EIGEN_STRONG_INLINE Packet4f pcmp_eq(
const Packet4f& a,
const Packet4f& b) {
896 return _mm_cmpeq_ps(a, b);
900EIGEN_STRONG_INLINE Packet2d pcmp_le(
const Packet2d& a,
const Packet2d& b) {
901 return _mm_cmple_pd(a, b);
904EIGEN_STRONG_INLINE Packet2d pcmp_lt(
const Packet2d& a,
const Packet2d& b) {
905 return _mm_cmplt_pd(a, b);
908EIGEN_STRONG_INLINE Packet2d pcmp_lt_or_nan(
const Packet2d& a,
const Packet2d& b) {
909 return _mm_cmpnge_pd(a, b);
912EIGEN_STRONG_INLINE Packet2d pcmp_eq(
const Packet2d& a,
const Packet2d& b) {
913 return _mm_cmpeq_pd(a, b);
916EIGEN_STRONG_INLINE Packet4i pcmp_lt(
const Packet4i& a,
const Packet4i& b) {
917 return _mm_cmplt_epi32(a, b);
920EIGEN_STRONG_INLINE Packet4i pcmp_eq(
const Packet4i& a,
const Packet4i& b) {
921 return _mm_cmpeq_epi32(a, b);
924EIGEN_STRONG_INLINE Packet4i pcmp_le(
const Packet4i& a,
const Packet4i& b) {
925#ifdef EIGEN_VECTORIZE_SSE4_1
926 return _mm_cmpeq_epi32(a, _mm_min_epi32(a, b));
928 return por(pcmp_lt(a, b), pcmp_eq(a, b));
932EIGEN_STRONG_INLINE Packet2l pcmp_lt(
const Packet2l& a,
const Packet2l& b) {
933#ifdef EIGEN_VECTORIZE_SSE4_2
934 return _mm_cmpgt_epi64(b, a);
936 Packet4i eq = pcmp_eq<Packet4i>(Packet4i(a), Packet4i(b));
937 Packet2l hi_eq = Packet2l(_mm_shuffle_epi32(eq, (shuffle_mask<1, 1, 3, 3>::mask)));
940 const Packet4i kLowSignFlip = _mm_setr_epi32(SIGN_MASK_I32, 0x0, SIGN_MASK_I32, 0x0);
941 Packet4i lt = pcmp_lt<Packet4i>(pxor(Packet4i(a), kLowSignFlip), pxor(Packet4i(b), kLowSignFlip));
942 Packet2l hi_lt = Packet2l(_mm_shuffle_epi32(lt, (shuffle_mask<1, 1, 3, 3>::mask)));
943 Packet2l lo_lt = Packet2l(_mm_shuffle_epi32(lt, (shuffle_mask<0, 0, 2, 2>::mask)));
945 return por(hi_lt, pand(hi_eq, lo_lt));
949EIGEN_STRONG_INLINE Packet2l pcmp_eq(
const Packet2l& a,
const Packet2l& b) {
950#ifdef EIGEN_VECTORIZE_SSE4_1
951 return _mm_cmpeq_epi64(a, b);
953 Packet4i tmp = pcmp_eq<Packet4i>(Packet4i(a), Packet4i(b));
954 return Packet2l(pand<Packet4i>(tmp, _mm_shuffle_epi32(tmp, (shuffle_mask<1, 0, 3, 2>::mask))));
958EIGEN_STRONG_INLINE Packet2l pcmp_le(
const Packet2l& a,
const Packet2l& b) {
959 return por(pcmp_lt(a, b), pcmp_eq(a, b));
962EIGEN_STRONG_INLINE Packet16b pcmp_eq(
const Packet16b& a,
const Packet16b& b) {
964 const Packet16b kBoolMask = pset1<Packet16b>(
true);
965 return _mm_and_si128(_mm_cmpeq_epi8(a, b), kBoolMask);
968EIGEN_STRONG_INLINE Packet4ui pcmp_eq(
const Packet4ui& a,
const Packet4ui& b) {
969 return _mm_cmpeq_epi32(a, b);
973EIGEN_STRONG_INLINE Packet4f pmin<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
974#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
979#ifdef EIGEN_VECTORIZE_AVX
981 asm(
"vminps %[a], %[b], %[res]" : [res]
"=x"(res) : [a]
"x"(a), [b]
"x"(b));
984 asm(
"minps %[a], %[res]" : [res]
"+x"(res) : [a]
"x"(a));
989 return _mm_min_ps(b, a);
993EIGEN_STRONG_INLINE Packet2d pmin<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
994#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
999#ifdef EIGEN_VECTORIZE_AVX
1001 asm(
"vminpd %[a], %[b], %[res]" : [res]
"=x"(res) : [a]
"x"(a), [b]
"x"(b));
1004 asm(
"minpd %[a], %[res]" : [res]
"+x"(res) : [a]
"x"(a));
1009 return _mm_min_pd(b, a);
1013EIGEN_STRONG_INLINE Packet2l pmin<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
1014 Packet2l a_lt_mask = pcmp_lt(a, b);
1015 return por(pandnot(b, a_lt_mask), pand(a, a_lt_mask));
1018EIGEN_STRONG_INLINE Packet4i pmin<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
1019#ifdef EIGEN_VECTORIZE_SSE4_1
1020 return _mm_min_epi32(a, b);
1023 Packet4i mask = _mm_cmplt_epi32(a, b);
1024 return _mm_or_si128(_mm_and_si128(mask, a), _mm_andnot_si128(mask, b));
1028EIGEN_STRONG_INLINE Packet4ui pmin<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
1029#ifdef EIGEN_VECTORIZE_SSE4_1
1030 return _mm_min_epu32(a, b);
1032 return padd((Packet4ui)pmin((Packet4i)psub(a, pset1<Packet4ui>(0x80000000UL)),
1033 (Packet4i)psub(b, pset1<Packet4ui>(0x80000000UL))),
1034 pset1<Packet4ui>(0x80000000UL));
1039EIGEN_STRONG_INLINE Packet4f pmax<Packet4f>(
const Packet4f& a,
const Packet4f& b) {
1040#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
1045#ifdef EIGEN_VECTORIZE_AVX
1047 asm(
"vmaxps %[a], %[b], %[res]" : [res]
"=x"(res) : [a]
"x"(a), [b]
"x"(b));
1050 asm(
"maxps %[a], %[res]" : [res]
"+x"(res) : [a]
"x"(a));
1055 return _mm_max_ps(b, a);
1059EIGEN_STRONG_INLINE Packet2d pmax<Packet2d>(
const Packet2d& a,
const Packet2d& b) {
1060#if EIGEN_GNUC_STRICT_LESS_THAN(6, 3, 0)
1065#ifdef EIGEN_VECTORIZE_AVX
1067 asm(
"vmaxpd %[a], %[b], %[res]" : [res]
"=x"(res) : [a]
"x"(a), [b]
"x"(b));
1070 asm(
"maxpd %[a], %[res]" : [res]
"+x"(res) : [a]
"x"(a));
1075 return _mm_max_pd(b, a);
1079EIGEN_STRONG_INLINE Packet2l pmax<Packet2l>(
const Packet2l& a,
const Packet2l& b) {
1080 Packet2l a_lt_mask = pcmp_lt(a, b);
1081 return por(pandnot(a, a_lt_mask), pand(b, a_lt_mask));
1084EIGEN_STRONG_INLINE Packet4i pmax<Packet4i>(
const Packet4i& a,
const Packet4i& b) {
1085#ifdef EIGEN_VECTORIZE_SSE4_1
1086 return _mm_max_epi32(a, b);
1089 Packet4i mask = _mm_cmpgt_epi32(a, b);
1090 return _mm_or_si128(_mm_and_si128(mask, a), _mm_andnot_si128(mask, b));
1094EIGEN_STRONG_INLINE Packet4ui pmax<Packet4ui>(
const Packet4ui& a,
const Packet4ui& b) {
1095#ifdef EIGEN_VECTORIZE_SSE4_1
1096 return _mm_max_epu32(a, b);
1098 return padd((Packet4ui)pmax((Packet4i)psub(a, pset1<Packet4ui>(0x80000000UL)),
1099 (Packet4i)psub(b, pset1<Packet4ui>(0x80000000UL))),
1100 pset1<Packet4ui>(0x80000000UL));
1105EIGEN_STRONG_INLINE Packet4ui pcmp_lt(
const Packet4ui& a,
const Packet4ui& b) {
1106#ifdef EIGEN_VECTORIZE_SSE4_1
1107 return pxor(pcmp_eq(a, pmax(a, b)), ptrue(a));
1109 return (Packet4ui)pcmp_lt((Packet4i)psub(a, pset1<Packet4ui>(0x80000000UL)),
1110 (Packet4i)psub(b, pset1<Packet4ui>(0x80000000UL)));
1114EIGEN_STRONG_INLINE Packet4ui pcmp_le(
const Packet4ui& a,
const Packet4ui& b) {
1115#ifdef EIGEN_VECTORIZE_SSE4_1
1116 return pcmp_eq(a, pmin(a, b));
1118 return (Packet4ui)pcmp_le((Packet4i)psub(a, pset1<Packet4ui>(0x80000000UL)),
1119 (Packet4i)psub(b, pset1<Packet4ui>(0x80000000UL)));
1123template <
typename Packet,
typename Op>
1124EIGEN_STRONG_INLINE Packet pminmax_propagate_numbers(
const Packet& a,
const Packet& b, Op op) {
1127 Packet not_nan_mask_a = pcmp_eq(a, a);
1128 Packet m = op(a, b);
1129 return pselect<Packet>(not_nan_mask_a, m, b);
1132template <
typename Packet,
typename Op>
1133EIGEN_STRONG_INLINE Packet pminmax_propagate_nan(
const Packet& a,
const Packet& b, Op op) {
1137 Packet not_nan_mask_b = pcmp_eq(b, b);
1138 Packet m = op(a, b);
1139 return pselect<Packet>(not_nan_mask_b, m, b);
1144EIGEN_STRONG_INLINE Packet4f pmin<PropagateNumbers, Packet4f>(
const Packet4f& a,
const Packet4f& b) {
1145 return pminmax_propagate_numbers(a, b, pmin<Packet4f>);
1148EIGEN_STRONG_INLINE Packet2d pmin<PropagateNumbers, Packet2d>(
const Packet2d& a,
const Packet2d& b) {
1149 return pminmax_propagate_numbers(a, b, pmin<Packet2d>);
1152EIGEN_STRONG_INLINE Packet4f pmax<PropagateNumbers, Packet4f>(
const Packet4f& a,
const Packet4f& b) {
1153 return pminmax_propagate_numbers(a, b, pmax<Packet4f>);
1156EIGEN_STRONG_INLINE Packet2d pmax<PropagateNumbers, Packet2d>(
const Packet2d& a,
const Packet2d& b) {
1157 return pminmax_propagate_numbers(a, b, pmax<Packet2d>);
1160EIGEN_STRONG_INLINE Packet4f pmin<PropagateNaN, Packet4f>(
const Packet4f& a,
const Packet4f& b) {
1161 return pminmax_propagate_nan(a, b, pmin<Packet4f>);
1164EIGEN_STRONG_INLINE Packet2d pmin<PropagateNaN, Packet2d>(
const Packet2d& a,
const Packet2d& b) {
1165 return pminmax_propagate_nan(a, b, pmin<Packet2d>);
1168EIGEN_STRONG_INLINE Packet4f pmax<PropagateNaN, Packet4f>(
const Packet4f& a,
const Packet4f& b) {
1169 return pminmax_propagate_nan(a, b, pmax<Packet4f>);
1172EIGEN_STRONG_INLINE Packet2d pmax<PropagateNaN, Packet2d>(
const Packet2d& a,
const Packet2d& b) {
1173 return pminmax_propagate_nan(a, b, pmax<Packet2d>);
1177EIGEN_STRONG_INLINE Packet4f psignbit(
const Packet4f& a) {
1178 return _mm_castsi128_ps(_mm_srai_epi32(_mm_castps_si128(a), 31));
1181EIGEN_STRONG_INLINE Packet2d psignbit(
const Packet2d& a) {
1182 Packet4f tmp = psignbit<Packet4f>(_mm_castpd_ps(a));
1183#ifdef EIGEN_VECTORIZE_AVX
1184 return _mm_castps_pd(_mm_permute_ps(tmp, (shuffle_mask<1, 1, 3, 3>::mask)));
1186 return _mm_castps_pd(_mm_shuffle_ps(tmp, tmp, (shuffle_mask<1, 1, 3, 3>::mask)));
1190EIGEN_STRONG_INLINE Packet4i psignbit(
const Packet4i& a) {
1191 return _mm_srai_epi32(a, 31);
1194EIGEN_STRONG_INLINE Packet2l psignbit(
const Packet2l& a) {
1195 Packet4i tmp = psignbit<Packet4i>(Packet4i(a));
1196 return Packet2l(_mm_shuffle_epi32(tmp, (shuffle_mask<1, 1, 3, 3>::mask)));
1200EIGEN_STRONG_INLINE Packet2l parithmetic_shift_right(
const Packet2l& a) {
1201 Packet2l signbit = psignbit(a);
1202 return por(_mm_slli_epi64(signbit, 64 - N), _mm_srli_epi64(a, N));
1205EIGEN_STRONG_INLINE Packet2l plogical_shift_right(
const Packet2l& a) {
1206 return _mm_srli_epi64(a, N);
1209EIGEN_STRONG_INLINE Packet2l plogical_shift_left(
const Packet2l& a) {
1210 return _mm_slli_epi64(a, N);
1213EIGEN_STRONG_INLINE Packet4i parithmetic_shift_right(
const Packet4i& a) {
1214 return _mm_srai_epi32(a, N);
1217EIGEN_STRONG_INLINE Packet4i plogical_shift_right(
const Packet4i& a) {
1218 return _mm_srli_epi32(a, N);
1221EIGEN_STRONG_INLINE Packet4i plogical_shift_left(
const Packet4i& a) {
1222 return _mm_slli_epi32(a, N);
1225EIGEN_STRONG_INLINE Packet4ui parithmetic_shift_right(
const Packet4ui& a) {
1226 return _mm_srli_epi32(a, N);
1229EIGEN_STRONG_INLINE Packet4ui plogical_shift_right(
const Packet4ui& a) {
1230 return _mm_srli_epi32(a, N);
1233EIGEN_STRONG_INLINE Packet4ui plogical_shift_left(
const Packet4ui& a) {
1234 return _mm_slli_epi32(a, N);
1238EIGEN_STRONG_INLINE Packet4f pabs(
const Packet4f& a) {
1239 const __m128i mask = _mm_setr_epi32(0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF);
1240 return _mm_castsi128_ps(_mm_and_si128(mask, _mm_castps_si128(a)));
1243EIGEN_STRONG_INLINE Packet2d pabs(
const Packet2d& a) {
1244 const __m128i mask = _mm_setr_epi32(-1, 0x7FFFFFFF, -1, 0x7FFFFFFF);
1245 return _mm_castsi128_pd(_mm_and_si128(mask, _mm_castpd_si128(a)));
1248EIGEN_STRONG_INLINE Packet2l pabs(
const Packet2l& a) {
1249 Packet2l signbit = psignbit(a);
1250 return _mm_sub_epi64(_mm_xor_si128(a, signbit), signbit);
1253EIGEN_STRONG_INLINE Packet4i pabs(
const Packet4i& a) {
1254#ifdef EIGEN_VECTORIZE_SSSE3
1255 return _mm_abs_epi32(a);
1257 Packet4i signbit = psignbit(a);
1258 return _mm_sub_epi32(_mm_xor_si128(a, signbit), signbit);
1261#ifdef EIGEN_VECTORIZE_SSE4_1
1263EIGEN_STRONG_INLINE Packet4f pround<Packet4f>(
const Packet4f& a) {
1265 const Packet4f mask = pset1frombits<Packet4f>(0x80000000u);
1266 const Packet4f prev0dot5 = pset1frombits<Packet4f>(0x3EFFFFFFu);
1267 return _mm_round_ps(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
1271EIGEN_STRONG_INLINE Packet2d pround<Packet2d>(
const Packet2d& a) {
1272 const Packet2d mask = _mm_castsi128_pd(_mm_set_epi64x(0x8000000000000000ull, 0x8000000000000000ull));
1273 const Packet2d prev0dot5 = _mm_castsi128_pd(_mm_set_epi64x(0x3FDFFFFFFFFFFFFFull, 0x3FDFFFFFFFFFFFFFull));
1274 return _mm_round_pd(padd(por(pand(a, mask), prev0dot5), a), _MM_FROUND_TO_ZERO);
1278EIGEN_STRONG_INLINE Packet4f print<Packet4f>(
const Packet4f& a) {
1279 return _mm_round_ps(a, _MM_FROUND_CUR_DIRECTION);
1282EIGEN_STRONG_INLINE Packet2d print<Packet2d>(
const Packet2d& a) {
1283 return _mm_round_pd(a, _MM_FROUND_CUR_DIRECTION);
1287EIGEN_STRONG_INLINE Packet4f pceil<Packet4f>(
const Packet4f& a) {
1288 return _mm_ceil_ps(a);
1291EIGEN_STRONG_INLINE Packet2d pceil<Packet2d>(
const Packet2d& a) {
1292 return _mm_ceil_pd(a);
1296EIGEN_STRONG_INLINE Packet4f pfloor<Packet4f>(
const Packet4f& a) {
1297 return _mm_floor_ps(a);
1300EIGEN_STRONG_INLINE Packet2d pfloor<Packet2d>(
const Packet2d& a) {
1301 return _mm_floor_pd(a);
1305EIGEN_STRONG_INLINE Packet4f ptrunc<Packet4f>(
const Packet4f& a) {
1306 return _mm_round_ps(a, _MM_FROUND_TRUNC);
1309EIGEN_STRONG_INLINE Packet2d ptrunc<Packet2d>(
const Packet2d& a) {
1310 return _mm_round_pd(a, _MM_FROUND_TRUNC);
1315EIGEN_STRONG_INLINE Packet4f pload<Packet4f>(
const float* from) {
1316 EIGEN_DEBUG_ALIGNED_LOAD
return _mm_load_ps(from);
1319EIGEN_STRONG_INLINE Packet2d pload<Packet2d>(
const double* from) {
1320 EIGEN_DEBUG_ALIGNED_LOAD
return _mm_load_pd(from);
1323EIGEN_STRONG_INLINE Packet2l pload<Packet2l>(
const int64_t* from) {
1324 EIGEN_DEBUG_ALIGNED_LOAD
return _mm_load_si128(
reinterpret_cast<const __m128i*
>(from));
1327EIGEN_STRONG_INLINE Packet4i pload<Packet4i>(
const int* from) {
1328 EIGEN_DEBUG_ALIGNED_LOAD
return _mm_load_si128(
reinterpret_cast<const __m128i*
>(from));
1331EIGEN_STRONG_INLINE Packet4ui pload<Packet4ui>(
const uint32_t* from) {
1332 EIGEN_DEBUG_ALIGNED_LOAD
return _mm_load_si128(
reinterpret_cast<const __m128i*
>(from));
1335EIGEN_STRONG_INLINE Packet16b pload<Packet16b>(
const bool* from) {
1336 EIGEN_DEBUG_ALIGNED_LOAD
return _mm_load_si128(
reinterpret_cast<const __m128i*
>(from));
1340EIGEN_STRONG_INLINE Packet4f ploadu<Packet4f>(
const float* from) {
1341 EIGEN_DEBUG_UNALIGNED_LOAD
1342 return _mm_loadu_ps(from);
1346EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(
const double* from) {
1347 EIGEN_DEBUG_UNALIGNED_LOAD
1348 return _mm_loadu_pd(from);
1351EIGEN_STRONG_INLINE Packet2l ploadu<Packet2l>(
const int64_t* from) {
1352 EIGEN_DEBUG_UNALIGNED_LOAD
1353 return _mm_loadu_si128(
reinterpret_cast<const __m128i*
>(from));
1356EIGEN_STRONG_INLINE Packet4i ploadu<Packet4i>(
const int* from) {
1357 EIGEN_DEBUG_UNALIGNED_LOAD
1358 return _mm_loadu_si128(
reinterpret_cast<const __m128i*
>(from));
1361EIGEN_STRONG_INLINE Packet4ui ploadu<Packet4ui>(
const uint32_t* from) {
1362 EIGEN_DEBUG_UNALIGNED_LOAD
1363 return _mm_loadu_si128(
reinterpret_cast<const __m128i*
>(from));
1366EIGEN_STRONG_INLINE Packet16b ploadu<Packet16b>(
const bool* from) {
1367 EIGEN_DEBUG_UNALIGNED_LOAD
1368 return _mm_loadu_si128(
reinterpret_cast<const __m128i*
>(from));
1371EIGEN_STRONG_INLINE __m128i ploadu_si64(
const void* from) {
1372#if EIGEN_GNUC_STRICT_LESS_THAN(9, 1, 0) || (EIGEN_COMP_MINGW && !EIGEN_COMP_CLANG && EIGEN_COMP_GNUC < 910)
1374 EIGEN_USING_STD(memcpy);
1376 memcpy(&lo, from,
sizeof(lo));
1377 return _mm_set_epi64((__m64)0LL, lo);
1379 return _mm_loadu_si64(from);
1384template <
typename Packet>
1385EIGEN_STRONG_INLINE Packet ploadl(
const typename unpacket_traits<Packet>::type* from);
1387EIGEN_STRONG_INLINE Packet4f ploadl<Packet4f>(
const float* from) {
1388 EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_castsi128_ps(ploadu_si64(
reinterpret_cast<const void*
>(from)));
1391EIGEN_STRONG_INLINE Packet2d ploadl<Packet2d>(
const double* from) {
1392 EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_load_sd(from);
1396template <
typename Packet>
1397EIGEN_STRONG_INLINE Packet ploads(
const typename unpacket_traits<Packet>::type* from);
1399EIGEN_STRONG_INLINE Packet4f ploads<Packet4f>(
const float* from) {
1400 EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_load_ss(from);
1403EIGEN_STRONG_INLINE Packet2d ploads<Packet2d>(
const double* from) {
1404 EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_load_sd(from);
1408EIGEN_STRONG_INLINE Packet4f ploaddup<Packet4f>(
const float* from) {
1409 return vec4f_swizzle1(_mm_castsi128_ps(ploadu_si64(
reinterpret_cast<const void*
>(from))), 0, 0, 1, 1);
1412EIGEN_STRONG_INLINE Packet4i ploaddup<Packet4i>(
const int* from) {
1414 tmp = _mm_loadl_epi64(
reinterpret_cast<const __m128i*
>(from));
1415 return vec4i_swizzle1(tmp, 0, 0, 1, 1);
1418EIGEN_STRONG_INLINE Packet4ui ploaddup<Packet4ui>(
const uint32_t* from) {
1420 tmp = _mm_loadl_epi64(
reinterpret_cast<const __m128i*
>(from));
1421 return vec4ui_swizzle1(tmp, 0, 0, 1, 1);
1427EIGEN_STRONG_INLINE Packet16b ploaddup<Packet16b>(
const bool* from) {
1428 __m128i tmp = ploadu_si64(
reinterpret_cast<const void*
>(from));
1429 return _mm_unpacklo_epi8(tmp, tmp);
1435EIGEN_STRONG_INLINE Packet16b ploadquad<Packet16b>(
const bool* from) {
1436 EIGEN_USING_STD(memcpy);
1438 memcpy(&val, from,
sizeof(
int));
1439 __m128i tmp = _mm_cvtsi32_si128(val);
1440 tmp = _mm_unpacklo_epi8(tmp, tmp);
1441 return _mm_unpacklo_epi16(tmp, tmp);
1445EIGEN_STRONG_INLINE
void pstore<float>(
float* to,
const Packet4f& from) {
1446 EIGEN_DEBUG_ALIGNED_STORE _mm_store_ps(to, from);
1449EIGEN_STRONG_INLINE
void pstore<double>(
double* to,
const Packet2d& from) {
1450 EIGEN_DEBUG_ALIGNED_STORE _mm_store_pd(to, from);
1453EIGEN_STRONG_INLINE
void pstore<int64_t>(int64_t* to,
const Packet2l& from) {
1454 EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(
reinterpret_cast<__m128i*
>(to), from);
1457EIGEN_STRONG_INLINE
void pstore<int>(
int* to,
const Packet4i& from) {
1458 EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(
reinterpret_cast<__m128i*
>(to), from);
1461EIGEN_STRONG_INLINE
void pstore<uint32_t>(uint32_t* to,
const Packet4ui& from) {
1462 EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(
reinterpret_cast<__m128i*
>(to), from);
1465EIGEN_STRONG_INLINE
void pstore<bool>(
bool* to,
const Packet16b& from) {
1466 EIGEN_DEBUG_ALIGNED_STORE _mm_store_si128(
reinterpret_cast<__m128i*
>(to), from);
1470EIGEN_STRONG_INLINE
void pstoreu<double>(
double* to,
const Packet2d& from) {
1471 EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_pd(to, from);
1474EIGEN_STRONG_INLINE
void pstoreu<float>(
float* to,
const Packet4f& from) {
1475 EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_ps(to, from);
1478EIGEN_STRONG_INLINE
void pstoreu<int64_t>(int64_t* to,
const Packet2l& from) {
1479 EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(
reinterpret_cast<__m128i*
>(to), from);
1482EIGEN_STRONG_INLINE
void pstoreu<int>(
int* to,
const Packet4i& from) {
1483 EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(
reinterpret_cast<__m128i*
>(to), from);
1486EIGEN_STRONG_INLINE
void pstoreu<uint32_t>(uint32_t* to,
const Packet4ui& from) {
1487 EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(
reinterpret_cast<__m128i*
>(to), from);
1490EIGEN_STRONG_INLINE
void pstoreu<bool>(
bool* to,
const Packet16b& from) {
1491 EIGEN_DEBUG_UNALIGNED_STORE _mm_storeu_si128(
reinterpret_cast<__m128i*
>(to), from);
1494template <
typename Scalar,
typename Packet>
1495EIGEN_STRONG_INLINE
void pstorel(Scalar* to,
const Packet& from);
1497EIGEN_STRONG_INLINE
void pstorel(
float* to,
const Packet4f& from) {
1498 EIGEN_DEBUG_UNALIGNED_STORE _mm_storel_pi(
reinterpret_cast<__m64*
>(to), from);
1501EIGEN_STRONG_INLINE
void pstorel(
double* to,
const Packet2d& from) {
1502 EIGEN_DEBUG_UNALIGNED_STORE _mm_storel_pd(to, from);
1505template <
typename Scalar,
typename Packet>
1506EIGEN_STRONG_INLINE
void pstores(Scalar* to,
const Packet& from);
1508EIGEN_STRONG_INLINE
void pstores(
float* to,
const Packet4f& from) {
1509 EIGEN_DEBUG_UNALIGNED_STORE _mm_store_ss(to, from);
1512EIGEN_STRONG_INLINE
void pstores(
double* to,
const Packet2d& from) {
1513 EIGEN_DEBUG_UNALIGNED_STORE _mm_store_sd(to, from);
1517EIGEN_STRONG_INLINE Packet4f preverse(
const Packet4f& a) {
1518 return _mm_shuffle_ps(a, a, 0x1B);
1521EIGEN_STRONG_INLINE Packet2d preverse(
const Packet2d& a) {
1522 return _mm_shuffle_pd(a, a, 0x1);
1525EIGEN_STRONG_INLINE Packet2l preverse(
const Packet2l& a) {
1526 return _mm_castpd_si128(preverse(_mm_castsi128_pd(a)));
1529EIGEN_STRONG_INLINE Packet4i preverse(
const Packet4i& a) {
1530 return _mm_shuffle_epi32(a, 0x1B);
1533EIGEN_STRONG_INLINE Packet4ui preverse(
const Packet4ui& a) {
1534 return _mm_shuffle_epi32(a, 0x1B);
1537EIGEN_STRONG_INLINE Packet16b preverse(
const Packet16b& a) {
1538#ifdef EIGEN_VECTORIZE_SSSE3
1539 __m128i mask = _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
1540 return _mm_shuffle_epi8(a, mask);
1542 Packet16b tmp = _mm_shuffle_epi32(a, _MM_SHUFFLE(0, 1, 2, 3));
1543 tmp = _mm_shufflehi_epi16(_mm_shufflelo_epi16(tmp, _MM_SHUFFLE(2, 3, 0, 1)), _MM_SHUFFLE(2, 3, 0, 1));
1544 return _mm_or_si128(_mm_slli_epi16(tmp, 8), _mm_srli_epi16(tmp, 8));
1549EIGEN_STRONG_INLINE
float pfirst<Packet4f>(
const Packet4f& a) {
1550 return _mm_cvtss_f32(a);
1553EIGEN_STRONG_INLINE
double pfirst<Packet2d>(
const Packet2d& a) {
1554 return _mm_cvtsd_f64(a);
1557EIGEN_STRONG_INLINE int64_t pfirst<Packet2l>(
const Packet2l& a) {
1558 return _mm_extract_epi64_0(a);
1561EIGEN_STRONG_INLINE
int pfirst<Packet4i>(
const Packet4i& a) {
1562 return _mm_cvtsi128_si32(a);
1565EIGEN_STRONG_INLINE uint32_t pfirst<Packet4ui>(
const Packet4ui& a) {
1566 return numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(a));
1569EIGEN_STRONG_INLINE
bool pfirst<Packet16b>(
const Packet16b& a) {
1570 int x = _mm_cvtsi128_si32(a);
1571 return static_cast<bool>(x & 1);
1575EIGEN_STRONG_INLINE Packet4f pgather<float, Packet4f>(
const float* from, Index stride) {
1578 return _mm_shuffle_ps(_mm_loadu_ps(from), _mm_loadu_ps(from + 3), _MM_SHUFFLE(3, 1, 2, 0));
1580 return _mm_set_ps(from[3 * stride], from[2 * stride], from[1 * stride], from[0 * stride]);
1583EIGEN_STRONG_INLINE Packet2d pgather<double, Packet2d>(
const double* from, Index stride) {
1584 return _mm_set_pd(from[1 * stride], from[0 * stride]);
1587EIGEN_STRONG_INLINE Packet2l pgather<int64_t, Packet2l>(
const int64_t* from, Index stride) {
1588 return _mm_set_epi64x(from[1 * stride], from[0 * stride]);
1591EIGEN_STRONG_INLINE Packet4i pgather<int, Packet4i>(
const int* from, Index stride) {
1592 return _mm_set_epi32(from[3 * stride], from[2 * stride], from[1 * stride], from[0 * stride]);
1595EIGEN_STRONG_INLINE Packet4ui pgather<uint32_t, Packet4ui>(
const uint32_t* from, Index stride) {
1596 return _mm_set_epi32(numext::bit_cast<int32_t>(from[3 * stride]), numext::bit_cast<int32_t>(from[2 * stride]),
1597 numext::bit_cast<int32_t>(from[1 * stride]), numext::bit_cast<int32_t>(from[0 * stride]));
1601EIGEN_STRONG_INLINE Packet16b pgather<bool, Packet16b>(
const bool* from, Index stride) {
1602 return _mm_set_epi8(from[15 * stride], from[14 * stride], from[13 * stride], from[12 * stride], from[11 * stride],
1603 from[10 * stride], from[9 * stride], from[8 * stride], from[7 * stride], from[6 * stride],
1604 from[5 * stride], from[4 * stride], from[3 * stride], from[2 * stride], from[1 * stride],
1609EIGEN_STRONG_INLINE
void pscatter<float, Packet4f>(
float* to,
const Packet4f& from, Index stride) {
1610 to[stride * 0] = pfirst(from);
1611 to[stride * 1] = pfirst(Packet4f(_mm_shuffle_ps(from, from, 1)));
1612 to[stride * 2] = pfirst(Packet4f(_mm_shuffle_ps(from, from, 2)));
1613 to[stride * 3] = pfirst(Packet4f(_mm_shuffle_ps(from, from, 3)));
1616EIGEN_STRONG_INLINE
void pscatter<double, Packet2d>(
double* to,
const Packet2d& from, Index stride) {
1617 to[stride * 0] = pfirst(from);
1618 to[stride * 1] = pfirst(preverse(from));
1621EIGEN_STRONG_INLINE
void pscatter<int64_t, Packet2l>(int64_t* to,
const Packet2l& from, Index stride) {
1622 to[stride * 0] = pfirst(from);
1623 to[stride * 1] = pfirst(preverse(from));
1626EIGEN_STRONG_INLINE
void pscatter<int, Packet4i>(
int* to,
const Packet4i& from, Index stride) {
1627 to[stride * 0] = _mm_cvtsi128_si32(from);
1628 to[stride * 1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1));
1629 to[stride * 2] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2));
1630 to[stride * 3] = _mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3));
1633EIGEN_STRONG_INLINE
void pscatter<uint32_t, Packet4ui>(uint32_t* to,
const Packet4ui& from, Index stride) {
1634 to[stride * 0] = numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(from));
1635 to[stride * 1] = numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(_mm_shuffle_epi32(from, 1)));
1636 to[stride * 2] = numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(_mm_shuffle_epi32(from, 2)));
1637 to[stride * 3] = numext::bit_cast<uint32_t>(_mm_cvtsi128_si32(_mm_shuffle_epi32(from, 3)));
1640EIGEN_STRONG_INLINE
void pscatter<bool, Packet16b>(
bool* to,
const Packet16b& from, Index stride) {
1641 EIGEN_ALIGN16
bool tmp[16];
1643 to[stride * 0] = tmp[0];
1644 to[stride * 1] = tmp[1];
1645 to[stride * 2] = tmp[2];
1646 to[stride * 3] = tmp[3];
1647 to[stride * 4] = tmp[4];
1648 to[stride * 5] = tmp[5];
1649 to[stride * 6] = tmp[6];
1650 to[stride * 7] = tmp[7];
1651 to[stride * 8] = tmp[8];
1652 to[stride * 9] = tmp[9];
1653 to[stride * 10] = tmp[10];
1654 to[stride * 11] = tmp[11];
1655 to[stride * 12] = tmp[12];
1656 to[stride * 13] = tmp[13];
1657 to[stride * 14] = tmp[14];
1658 to[stride * 15] = tmp[15];
1663EIGEN_STRONG_INLINE
void pstore1<Packet4f>(
float* to,
const float& a) {
1664 Packet4f pa = _mm_set_ss(a);
1665 pstore(to, Packet4f(vec4f_swizzle1(pa, 0, 0, 0, 0)));
1669EIGEN_STRONG_INLINE
void pstore1<Packet2d>(
double* to,
const double& a) {
1670 Packet2d pa = _mm_set_sd(a);
1671 pstore(to, Packet2d(vec2d_swizzle1(pa, 0, 0)));
1674#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
1675using SsePrefetchPtrType =
const void*;
1677using SsePrefetchPtrType =
const char*;
1680#ifndef EIGEN_VECTORIZE_AVX
1682EIGEN_STRONG_INLINE
void prefetch<float>(
const float* addr) {
1683 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1686EIGEN_STRONG_INLINE
void prefetch<double>(
const double* addr) {
1687 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1690EIGEN_STRONG_INLINE
void prefetch<int>(
const int* addr) {
1691 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1694EIGEN_STRONG_INLINE
void prefetch<int64_t>(
const int64_t* addr) {
1695 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1698EIGEN_STRONG_INLINE
void prefetch<uint32_t>(
const uint32_t* addr) {
1699 _mm_prefetch((SsePrefetchPtrType)(addr), _MM_HINT_T0);
1704EIGEN_STRONG_INLINE Packet4f pfrexp<Packet4f>(
const Packet4f& a, Packet4f& exponent) {
1705 return pfrexp_generic(a, exponent);
1710EIGEN_STRONG_INLINE Packet2d pfrexp_generic_get_biased_exponent(
const Packet2d& a) {
1711 const Packet2d cst_exp_mask = pset1frombits<Packet2d>(
static_cast<uint64_t
>(0x7ff0000000000000ull));
1712 __m128i a_expo = _mm_srli_epi64(_mm_castpd_si128(pand(a, cst_exp_mask)), 52);
1713 return _mm_cvtepi32_pd(vec4i_swizzle1(a_expo, 0, 2, 1, 3));
1717EIGEN_STRONG_INLINE Packet2d pfrexp<Packet2d>(
const Packet2d& a, Packet2d& exponent) {
1718 return pfrexp_generic(a, exponent);
1722EIGEN_STRONG_INLINE Packet4f pldexp<Packet4f>(
const Packet4f& a,
const Packet4f& exponent) {
1723 return pldexp_generic(a, exponent);
1729EIGEN_STRONG_INLINE Packet2d pldexp<Packet2d>(
const Packet2d& a,
const Packet2d& exponent) {
1733 const Packet2d max_exponent = pset1<Packet2d>(2099.0);
1734 const Packet2d last_max = pset1<Packet2d>(1022.0);
1735 const Packet4i e = _mm_cvttpd_epi32(pmin(pmax(exponent, pnegate(max_exponent)), max_exponent));
1736 const Packet4i b = _mm_cvttpd_epi32(pmin(pmax(exponent, pnegate(last_max)), last_max));
1737 const Packet4i t = pandnot(psub(e, b), pset1<Packet4i>(1));
1738 const Packet4i biased =
1739 padd(Packet4i(_mm_unpacklo_epi32(t, psub(e, t))), Packet4i(_mm_set_epi32(1023, 2046, 1023, 2046)));
1740 const Packet2d c1 = _mm_castsi128_pd(_mm_slli_epi64(biased, 51));
1741 const Packet2d c2 = _mm_castsi128_pd(_mm_slli_epi64(_mm_srli_epi64(biased, 32), 52));
1742 return pldexp_apply_factors(a, c1, c2);
1748EIGEN_STRONG_INLINE Packet2d pldexp_fast<Packet2d>(
const Packet2d& a,
const Packet2d& exponent) {
1750 const Packet2d min_exponent = pset1<Packet2d>(-1023.0);
1751 const Packet2d max_exponent = pset1<Packet2d>(1024.0);
1752 const Packet2d e = pmin(pmax(exponent, min_exponent), max_exponent);
1755 const Packet4i ei = vec4i_swizzle1(_mm_cvtpd_epi32(e), 0, 3, 1, 3);
1758 const Packet4i bias = _mm_set_epi32(0, 1023, 0, 1023);
1759 const Packet2d c = _mm_castsi128_pd(_mm_slli_epi64(padd(ei, bias), 52));
1766EIGEN_STRONG_INLINE
void pbroadcast4<Packet4f>(
const float* a, Packet4f& a0, Packet4f& a1, Packet4f& a2, Packet4f& a3) {
1767 a3 = pload<Packet4f>(a);
1768 a0 = vec4f_swizzle1(a3, 0, 0, 0, 0);
1769 a1 = vec4f_swizzle1(a3, 1, 1, 1, 1);
1770 a2 = vec4f_swizzle1(a3, 2, 2, 2, 2);
1771 a3 = vec4f_swizzle1(a3, 3, 3, 3, 3);
1774EIGEN_STRONG_INLINE
void pbroadcast4<Packet2d>(
const double* a, Packet2d& a0, Packet2d& a1, Packet2d& a2,
1776#ifdef EIGEN_VECTORIZE_SSE3
1777 a0 = _mm_loaddup_pd(a + 0);
1778 a1 = _mm_loaddup_pd(a + 1);
1779 a2 = _mm_loaddup_pd(a + 2);
1780 a3 = _mm_loaddup_pd(a + 3);
1782 a1 = pload<Packet2d>(a);
1783 a0 = vec2d_swizzle1(a1, 0, 0);
1784 a1 = vec2d_swizzle1(a1, 1, 1);
1785 a3 = pload<Packet2d>(a + 2);
1786 a2 = vec2d_swizzle1(a3, 0, 0);
1787 a3 = vec2d_swizzle1(a3, 1, 1);
1792EIGEN_STRONG_INLINE
void punpackp(Packet4f* vecs) {
1793 vecs[1] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x55));
1794 vecs[2] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xAA));
1795 vecs[3] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0xFF));
1796 vecs[0] = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(vecs[0]), 0x00));
1799EIGEN_STRONG_INLINE
void ptranspose(PacketBlock<Packet4f, 4>& kernel) {
1800 _MM_TRANSPOSE4_PS(kernel.packet[0], kernel.packet[1], kernel.packet[2], kernel.packet[3]);
1803EIGEN_STRONG_INLINE
void ptranspose(PacketBlock<Packet2d, 2>& kernel) {
1804 __m128d tmp = _mm_unpackhi_pd(kernel.packet[0], kernel.packet[1]);
1805 kernel.packet[0] = _mm_unpacklo_pd(kernel.packet[0], kernel.packet[1]);
1806 kernel.packet[1] = tmp;
1809EIGEN_STRONG_INLINE
void ptranspose(PacketBlock<Packet2l, 2>& kernel) {
1810 __m128i tmp = _mm_unpackhi_epi64(kernel.packet[0], kernel.packet[1]);
1811 kernel.packet[0] = _mm_unpacklo_epi64(kernel.packet[0], kernel.packet[1]);
1812 kernel.packet[1] = tmp;
1815EIGEN_STRONG_INLINE
void ptranspose(PacketBlock<Packet4i, 4>& kernel) {
1816 __m128i T0 = _mm_unpacklo_epi32(kernel.packet[0], kernel.packet[1]);
1817 __m128i T1 = _mm_unpacklo_epi32(kernel.packet[2], kernel.packet[3]);
1818 __m128i T2 = _mm_unpackhi_epi32(kernel.packet[0], kernel.packet[1]);
1819 __m128i T3 = _mm_unpackhi_epi32(kernel.packet[2], kernel.packet[3]);
1821 kernel.packet[0] = _mm_unpacklo_epi64(T0, T1);
1822 kernel.packet[1] = _mm_unpackhi_epi64(T0, T1);
1823 kernel.packet[2] = _mm_unpacklo_epi64(T2, T3);
1824 kernel.packet[3] = _mm_unpackhi_epi64(T2, T3);
1826EIGEN_STRONG_INLINE
void ptranspose(PacketBlock<Packet4ui, 4>& kernel) {
1827 ptranspose((PacketBlock<Packet4i, 4>&)kernel);
1830EIGEN_STRONG_INLINE
void ptranspose(PacketBlock<Packet16b, 4>& kernel) {
1831 __m128i T0 = _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]);
1832 __m128i T1 = _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]);
1833 __m128i T2 = _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]);
1834 __m128i T3 = _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]);
1835 kernel.packet[0] = _mm_unpacklo_epi16(T0, T2);
1836 kernel.packet[1] = _mm_unpackhi_epi16(T0, T2);
1837 kernel.packet[2] = _mm_unpacklo_epi16(T1, T3);
1838 kernel.packet[3] = _mm_unpackhi_epi16(T1, T3);
1841EIGEN_STRONG_INLINE
void ptranspose(PacketBlock<Packet16b, 16>& kernel) {
1854 _mm_unpacklo_epi8(kernel.packet[0], kernel.packet[1]);
1856 _mm_unpackhi_epi8(kernel.packet[0], kernel.packet[1]);
1858 _mm_unpacklo_epi8(kernel.packet[2], kernel.packet[3]);
1860 _mm_unpackhi_epi8(kernel.packet[2], kernel.packet[3]);
1862 _mm_unpacklo_epi8(kernel.packet[4], kernel.packet[5]);
1863 __m128i t5 = _mm_unpackhi_epi8(kernel.packet[4], kernel.packet[5]);
1864 __m128i t6 = _mm_unpacklo_epi8(kernel.packet[6], kernel.packet[7]);
1865 __m128i t7 = _mm_unpackhi_epi8(kernel.packet[6], kernel.packet[7]);
1866 __m128i t8 = _mm_unpacklo_epi8(kernel.packet[8], kernel.packet[9]);
1867 __m128i t9 = _mm_unpackhi_epi8(kernel.packet[8], kernel.packet[9]);
1868 __m128i ta = _mm_unpacklo_epi8(kernel.packet[10], kernel.packet[11]);
1869 __m128i tb = _mm_unpackhi_epi8(kernel.packet[10], kernel.packet[11]);
1870 __m128i tc = _mm_unpacklo_epi8(kernel.packet[12], kernel.packet[13]);
1871 __m128i td = _mm_unpackhi_epi8(kernel.packet[12], kernel.packet[13]);
1872 __m128i te = _mm_unpacklo_epi8(kernel.packet[14], kernel.packet[15]);
1873 __m128i tf = _mm_unpackhi_epi8(kernel.packet[14], kernel.packet[15]);
1875 __m128i s0 = _mm_unpacklo_epi16(t0, t2);
1876 __m128i s1 = _mm_unpackhi_epi16(t0, t2);
1877 __m128i s2 = _mm_unpacklo_epi16(t1, t3);
1878 __m128i s3 = _mm_unpackhi_epi16(t1, t3);
1879 __m128i s4 = _mm_unpacklo_epi16(t4, t6);
1880 __m128i s5 = _mm_unpackhi_epi16(t4, t6);
1881 __m128i s6 = _mm_unpacklo_epi16(t5, t7);
1882 __m128i s7 = _mm_unpackhi_epi16(t5, t7);
1883 __m128i s8 = _mm_unpacklo_epi16(t8, ta);
1884 __m128i s9 = _mm_unpackhi_epi16(t8, ta);
1885 __m128i sa = _mm_unpacklo_epi16(t9, tb);
1886 __m128i sb = _mm_unpackhi_epi16(t9, tb);
1887 __m128i sc = _mm_unpacklo_epi16(tc, te);
1888 __m128i sd = _mm_unpackhi_epi16(tc, te);
1889 __m128i se = _mm_unpacklo_epi16(td, tf);
1890 __m128i sf = _mm_unpackhi_epi16(td, tf);
1892 __m128i u0 = _mm_unpacklo_epi32(s0, s4);
1893 __m128i u1 = _mm_unpackhi_epi32(s0, s4);
1894 __m128i u2 = _mm_unpacklo_epi32(s1, s5);
1895 __m128i u3 = _mm_unpackhi_epi32(s1, s5);
1896 __m128i u4 = _mm_unpacklo_epi32(s2, s6);
1897 __m128i u5 = _mm_unpackhi_epi32(s2, s6);
1898 __m128i u6 = _mm_unpacklo_epi32(s3, s7);
1899 __m128i u7 = _mm_unpackhi_epi32(s3, s7);
1900 __m128i u8 = _mm_unpacklo_epi32(s8, sc);
1901 __m128i u9 = _mm_unpackhi_epi32(s8, sc);
1902 __m128i ua = _mm_unpacklo_epi32(s9, sd);
1903 __m128i ub = _mm_unpackhi_epi32(s9, sd);
1904 __m128i uc = _mm_unpacklo_epi32(sa, se);
1905 __m128i ud = _mm_unpackhi_epi32(sa, se);
1906 __m128i ue = _mm_unpacklo_epi32(sb, sf);
1907 __m128i uf = _mm_unpackhi_epi32(sb, sf);
1909 kernel.packet[0] = _mm_unpacklo_epi64(u0, u8);
1910 kernel.packet[1] = _mm_unpackhi_epi64(u0, u8);
1911 kernel.packet[2] = _mm_unpacklo_epi64(u1, u9);
1912 kernel.packet[3] = _mm_unpackhi_epi64(u1, u9);
1913 kernel.packet[4] = _mm_unpacklo_epi64(u2, ua);
1914 kernel.packet[5] = _mm_unpackhi_epi64(u2, ua);
1915 kernel.packet[6] = _mm_unpacklo_epi64(u3, ub);
1916 kernel.packet[7] = _mm_unpackhi_epi64(u3, ub);
1917 kernel.packet[8] = _mm_unpacklo_epi64(u4, uc);
1918 kernel.packet[9] = _mm_unpackhi_epi64(u4, uc);
1919 kernel.packet[10] = _mm_unpacklo_epi64(u5, ud);
1920 kernel.packet[11] = _mm_unpackhi_epi64(u5, ud);
1921 kernel.packet[12] = _mm_unpacklo_epi64(u6, ue);
1922 kernel.packet[13] = _mm_unpackhi_epi64(u6, ue);
1923 kernel.packet[14] = _mm_unpacklo_epi64(u7, uf);
1924 kernel.packet[15] = _mm_unpackhi_epi64(u7, uf);
1928#if defined(EIGEN_VECTORIZE_FMA)
1930EIGEN_STRONG_INLINE
float pmadd(
const float& a,
const float& b,
const float& c) {
1931 return numext::fma(a, b, c);
1934EIGEN_STRONG_INLINE
double pmadd(
const double& a,
const double& b,
const double& c) {
1935 return numext::fma(a, b, c);
1938EIGEN_STRONG_INLINE
float pmsub(
const float& a,
const float& b,
const float& c) {
1939 return numext::fma(a, b, -c);
1942EIGEN_STRONG_INLINE
double pmsub(
const double& a,
const double& b,
const double& c) {
1943 return numext::fma(a, b, -c);
1946EIGEN_STRONG_INLINE
float pnmadd(
const float& a,
const float& b,
const float& c) {
1947 return numext::fma(-a, b, c);
1950EIGEN_STRONG_INLINE
double pnmadd(
const double& a,
const double& b,
const double& c) {
1951 return numext::fma(-a, b, c);
1954EIGEN_STRONG_INLINE
float pnmsub(
const float& a,
const float& b,
const float& c) {
1955 return numext::fma(-a, b, -c);
1958EIGEN_STRONG_INLINE
double pnmsub(
const double& a,
const double& b,
const double& c) {
1959 return numext::fma(-a, b, -c);
1963#ifdef EIGEN_VECTORIZE_SSE4_1
1966EIGEN_STRONG_INLINE __m128i half2floatsse(__m128i h) {
1967 __m128i input = _mm_cvtepu16_epi32(h);
1970 __m128i shifted_exp = _mm_set1_epi32(0x7c00 << 13);
1972 __m128i ou = _mm_slli_epi32(_mm_and_si128(input, _mm_set1_epi32(0x7fff)), 13);
1974 __m128i exp = _mm_and_si128(ou, shifted_exp);
1976 ou = _mm_add_epi32(ou, _mm_set1_epi32((127 - 15) << 23));
1979 __m128i naninf_mask = _mm_cmpeq_epi32(exp, shifted_exp);
1981 __m128i naninf_adj = _mm_and_si128(_mm_set1_epi32((128 - 16) << 23), naninf_mask);
1983 ou = _mm_add_epi32(ou, naninf_adj);
1986 __m128i zeroden_mask = _mm_cmpeq_epi32(exp, _mm_setzero_si128());
1987 __m128i zeroden_adj = _mm_and_si128(zeroden_mask, _mm_set1_epi32(1 << 23));
1989 ou = _mm_add_epi32(ou, zeroden_adj);
1991 __m128i magic = _mm_and_si128(zeroden_mask, _mm_set1_epi32(113 << 23));
1993 ou = _mm_castps_si128(_mm_sub_ps(_mm_castsi128_ps(ou), _mm_castsi128_ps(magic)));
1995 __m128i sign = _mm_slli_epi32(_mm_and_si128(input, _mm_set1_epi32(0x8000)), 16);
1997 ou = _mm_or_si128(ou, sign);
2004EIGEN_STRONG_INLINE __m128i float2half(__m128 f) {
2006 __m128i sign = _mm_set1_epi32(0x80000000u);
2008 sign = _mm_and_si128(sign, _mm_castps_si128(f));
2010 f = _mm_xor_ps(f, _mm_castsi128_ps(sign));
2012 __m128i fu = _mm_castps_si128(f);
2014 __m128i f16max = _mm_set1_epi32((127 + 16) << 23);
2015 __m128i f32infty = _mm_set1_epi32(255 << 23);
2018 __m128i infnan_mask = _mm_cmplt_epi32(f16max, _mm_castps_si128(f));
2019 __m128i inf_mask = _mm_cmpgt_epi32(_mm_castps_si128(f), f32infty);
2020 __m128i nan_mask = _mm_andnot_si128(inf_mask, infnan_mask);
2021 __m128i inf_value = _mm_and_si128(inf_mask, _mm_set1_epi32(0x7e00));
2022 __m128i nan_value = _mm_and_si128(nan_mask, _mm_set1_epi32(0x7c00));
2024 __m128i naninf_value = _mm_or_si128(inf_value, nan_value);
2026 __m128i denorm_magic = _mm_set1_epi32(((127 - 15) + (23 - 10) + 1) << 23);
2027 __m128i subnorm_mask = _mm_cmplt_epi32(_mm_castps_si128(f), _mm_set1_epi32(113 << 23));
2029 f = _mm_add_ps(f, _mm_castsi128_ps(denorm_magic));
2031 __m128i o = _mm_sub_epi32(_mm_castps_si128(f), denorm_magic);
2032 o = _mm_and_si128(o, subnorm_mask);
2034 o = _mm_or_si128(o, naninf_value);
2036 __m128i mask = _mm_or_si128(infnan_mask, subnorm_mask);
2037 o = _mm_and_si128(o, mask);
2040 __m128i mand_odd = _mm_and_si128(_mm_srli_epi32(fu, 13), _mm_set1_epi32(0x1));
2042 fu = _mm_add_epi32(fu, _mm_set1_epi32(0xc8000fffU));
2044 fu = _mm_add_epi32(fu, mand_odd);
2045 fu = _mm_andnot_si128(mask, fu);
2047 fu = _mm_srli_epi32(fu, 13);
2048 o = _mm_or_si128(fu, o);
2051 o = _mm_or_si128(o, _mm_srli_epi32(sign, 16));
2054 return _mm_and_si128(o, _mm_set1_epi32(0xffff));
2061EIGEN_STRONG_INLINE __m128i pudiv_magic_epu32(
const __m128i& a, uint32_t magic, uint32_t addend,
int shift) {
2062 __m128i m = _mm_set1_epi32(
static_cast<int>(magic));
2063 __m128i c = _mm_set1_epi64x(
static_cast<long long>(addend));
2064 __m128i even = _mm_srli_epi64(_mm_add_epi64(_mm_mul_epu32(a, m), c), 32);
2065 __m128i odd = _mm_add_epi64(_mm_mul_epu32(_mm_srli_epi64(a, 32), m), c);
2066#ifdef EIGEN_VECTORIZE_SSE4_1
2067 __m128i t = _mm_blend_epi16(even, odd, 0xCC);
2069 __m128i t = _mm_or_si128(even, _mm_and_si128(odd, _mm_set_epi32(-1, 0, -1, 0)));
2071 return _mm_srl_epi32(t, _mm_cvtsi32_si128(shift));
2078#if EIGEN_ARCH_i386_OR_x86_64
2079EIGEN_STRONG_INLINE __m128i pudiv_magic_epu64(
const __m128i& a, uint64_t magic, uint64_t addend,
int shift) {
2080 static_assert(int_div::use_multiply_add<uint64_t>::value,
"the 64-bit kernels take multiply-add constants");
2081 __m128i m_lo = _mm_set1_epi64x(
static_cast<long long>(magic));
2082 __m128i m_hi = _mm_set1_epi64x(
static_cast<long long>(magic >> 32));
2083 __m128i c_lo = _mm_set1_epi64x(
static_cast<long long>(addend & 0xffffffffu));
2084 __m128i c_hi = _mm_set1_epi64x(
static_cast<long long>(addend >> 32));
2085 __m128i a_hi = _mm_srli_epi64(a, 32);
2086 __m128i u0 = _mm_add_epi64(_mm_mul_epu32(a, m_lo), c_lo);
2087 __m128i u = _mm_add_epi64(_mm_mul_epu32(a_hi, m_lo), _mm_srli_epi64(u0, 32));
2088 __m128i w = _mm_add_epi64(_mm_add_epi64(_mm_mul_epu32(a, m_hi), _mm_and_si128(u, _mm_set1_epi64x(0xffffffff))), c_hi);
2089 __m128i t = _mm_add_epi64(_mm_add_epi64(_mm_mul_epu32(a_hi, m_hi), _mm_srli_epi64(u, 32)), _mm_srli_epi64(w, 32));
2090 return _mm_srl_epi64(t, _mm_cvtsi32_si128(shift));
2094EIGEN_STRONG_INLINE Packet2l pudiv_magic<Packet2l>(
const Packet2l& a, uint64_t magic, uint64_t addend,
int shift) {
2095 return pudiv_magic_epu64(a, magic, addend, shift);
2101#ifdef EIGEN_VECTORIZE_SSE4_1
2103EIGEN_STRONG_INLINE __m128i psdiv_signed_magic_epi32(
const __m128i& a, uint32_t magic,
int shift,
int ,
2104 const __m128i& divisor_sign) {
2105 __m128i m = _mm_set1_epi32(
static_cast<int>(magic));
2106 __m128i even = _mm_srli_epi64(_mm_mul_epi32(a, m), 32);
2107 __m128i odd = _mm_mul_epi32(_mm_srli_epi64(a, 32), m);
2108 __m128i t = _mm_add_epi32(a, _mm_blend_epi16(even, odd, 0xCC));
2109 __m128i q = _mm_sub_epi32(_mm_sra_epi32(t, _mm_cvtsi32_si128(shift)), _mm_srai_epi32(a, 31));
2110 return _mm_sub_epi32(_mm_xor_si128(q, divisor_sign), divisor_sign);
2115EIGEN_STRONG_INLINE __m128i psdiv_signed_magic_epi32(
const __m128i& a, uint32_t magic,
int ,
int total_shift,
2116 const __m128i& divisor_sign) {
2117 __m128i m = _mm_set1_epi32(
static_cast<int>(magic));
2118 __m128i count = _mm_cvtsi32_si128(total_shift);
2119 __m128i a_sign = _mm_srai_epi32(a, 31);
2120 __m128i abs_a = _mm_sub_epi32(_mm_xor_si128(a, a_sign), a_sign);
2121 __m128i even = _mm_srl_epi64(_mm_mul_epu32(abs_a, m), count);
2122 __m128i odd = _mm_srl_epi64(_mm_mul_epu32(_mm_srli_epi64(abs_a, 32), m), count);
2123 __m128i q = _mm_or_si128(even, _mm_slli_epi64(odd, 32));
2124 __m128i q_sign = _mm_xor_si128(a_sign, divisor_sign);
2125 return _mm_sub_epi32(_mm_xor_si128(q, q_sign), q_sign);
2130EIGEN_STRONG_INLINE Packet4ui pudiv_magic<Packet4ui>(
const Packet4ui& a, uint32_t magic, uint32_t addend,
int shift) {
2131 return pudiv_magic_epu32(a, magic, addend, shift);
2134EIGEN_STRONG_INLINE Packet4i psdiv_signed_magic<Packet4i>(
const Packet4i& a, uint32_t magic,
int shift,
int total_shift,
2135 const Packet4i& divisor_sign) {
2136 return psdiv_signed_magic_epi32(a, magic, shift, total_shift, divisor_sign);
2143#if EIGEN_COMP_PGI && EIGEN_COMP_PGI < 1900
2145static inline __m128 _mm_castpd_ps(__m128d x) {
return reinterpret_cast<__m128&
>(x); }
2146static inline __m128i _mm_castpd_si128(__m128d x) {
return reinterpret_cast<__m128i&
>(x); }
2147static inline __m128d _mm_castps_pd(__m128 x) {
return reinterpret_cast<__m128d&
>(x); }
2148static inline __m128i _mm_castps_si128(__m128 x) {
return reinterpret_cast<__m128i&
>(x); }
2149static inline __m128 _mm_castsi128_ps(__m128i x) {
return reinterpret_cast<__m128&
>(x); }
2150static inline __m128d _mm_castsi128_pd(__m128i x) {
return reinterpret_cast<__m128d&
>(x); }
@ Aligned16
Definition Constants.h:238