cannam@167: /*
cannam@167:  * Copyright (c) 2003, 2007-14 Matteo Frigo
cannam@167:  * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
cannam@167:  *
cannam@167:  * This program is free software; you can redistribute it and/or modify
cannam@167:  * it under the terms of the GNU General Public License as published by
cannam@167:  * the Free Software Foundation; either version 2 of the License, or
cannam@167:  * (at your option) any later version.
cannam@167:  *
cannam@167:  * This program is distributed in the hope that it will be useful,
cannam@167:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
cannam@167:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
cannam@167:  * GNU General Public License for more details.
cannam@167:  *
cannam@167:  * You should have received a copy of the GNU General Public License
cannam@167:  * along with this program; if not, write to the Free Software
cannam@167:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
cannam@167:  *
cannam@167:  */
cannam@167: 
cannam@167: #if defined(FFTW_LDOUBLE) || defined(FFTW_QUAD)
cannam@167: #  error "SSE/SSE2 only works in single/double precision"
cannam@167: #endif
cannam@167: 
cannam@167: #ifdef FFTW_SINGLE
cannam@167: #  define DS(d,s) s /* single-precision option */
cannam@167: #  define SUFF(name) name ## s
cannam@167: #else
cannam@167: #  define DS(d,s) d /* double-precision option */
cannam@167: #  define SUFF(name) name ## d
cannam@167: #endif
cannam@167: 
cannam@167: #define SIMD_SUFFIX  _sse2  /* for renaming */
cannam@167: #define VL DS(1,2)         /* SIMD vector length, in term of complex numbers */
cannam@167: #define SIMD_VSTRIDE_OKA(x) DS(1,((x) == 2))
cannam@167: #define SIMD_STRIDE_OKPAIR SIMD_STRIDE_OK
cannam@167: 
cannam@167: #if defined(__GNUC__) && !defined(FFTW_SINGLE) && !defined(__SSE2__)
cannam@167: #  error "compiling simd-sse2.h in double precision without -msse2"
cannam@167: #elif defined(__GNUC__) && defined(FFTW_SINGLE) && !defined(__SSE__)
cannam@167: #  error "compiling simd-sse2.h in single precision without -msse"
cannam@167: #endif
cannam@167: 
cannam@167: #ifdef _MSC_VER
cannam@167: #ifndef inline
cannam@167: #define inline __inline
cannam@167: #endif
cannam@167: #endif
cannam@167: 
cannam@167: /* some versions of glibc's sys/cdefs.h define __inline to be empty,
cannam@167:    which is wrong because emmintrin.h defines several inline
cannam@167:    procedures */
cannam@167: #ifndef _MSC_VER
cannam@167: #undef __inline
cannam@167: #endif
cannam@167: 
cannam@167: #ifdef FFTW_SINGLE
cannam@167: #  include <xmmintrin.h>
cannam@167: #else
cannam@167: #  include <emmintrin.h>
cannam@167: #endif
cannam@167: 
cannam@167: typedef DS(__m128d,__m128) V;
cannam@167: #define VADD SUFF(_mm_add_p)
cannam@167: #define VSUB SUFF(_mm_sub_p)
cannam@167: #define VMUL SUFF(_mm_mul_p)
cannam@167: #define VXOR SUFF(_mm_xor_p)
cannam@167: #define SHUF SUFF(_mm_shuffle_p)
cannam@167: #define UNPCKL SUFF(_mm_unpacklo_p)
cannam@167: #define UNPCKH SUFF(_mm_unpackhi_p)
cannam@167: 
cannam@167: #define SHUFVALS(fp0,fp1,fp2,fp3) \
cannam@167:    (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | ((fp0)))
cannam@167: 
cannam@167: #define VDUPL(x) DS(UNPCKL(x, x), SHUF(x, x, SHUFVALS(0, 0, 2, 2)))
cannam@167: #define VDUPH(x) DS(UNPCKH(x, x), SHUF(x, x, SHUFVALS(1, 1, 3, 3)))
cannam@167: #define STOREH(a, v) DS(_mm_storeh_pd(a, v), _mm_storeh_pi((__m64 *)(a), v))
cannam@167: #define STOREL(a, v) DS(_mm_storel_pd(a, v), _mm_storel_pi((__m64 *)(a), v))
cannam@167: 
cannam@167: 
cannam@167: #ifdef __GNUC__
cannam@167:   /*
cannam@167:    * gcc-3.3 generates slow code for mm_set_ps (write all elements to
cannam@167:    * the stack and load __m128 from the stack).
cannam@167:    *
cannam@167:    * gcc-3.[34] generates slow code for mm_set_ps1 (load into low element
cannam@167:    * and shuffle).
cannam@167:    *
cannam@167:    * This hack forces gcc to generate a constant __m128 at compile time.
cannam@167:    */
cannam@167:   union rvec {
cannam@167:        R r[DS(2,4)];
cannam@167:        V v;
cannam@167:   };
cannam@167: 
cannam@167: #  ifdef FFTW_SINGLE
cannam@167: #    define DVK(var, val) V var = __extension__ ({ \
cannam@167:          static const union rvec _var = { {val,val,val,val} }; _var.v; })
cannam@167: #  else
cannam@167: #    define DVK(var, val) V var = __extension__ ({ \
cannam@167:          static const union rvec _var = { {val,val} }; _var.v; })
cannam@167: #  endif
cannam@167: #  define LDK(x) x
cannam@167: #else
cannam@167: #  define DVK(var, val) const R var = K(val)
cannam@167: #  define LDK(x) DS(_mm_set1_pd,_mm_set_ps1)(x)
cannam@167: #endif
cannam@167: 
cannam@167: static inline V LDA(const R *x, INT ivs, const R *aligned_like)
cannam@167: {
cannam@167:      (void)aligned_like; /* UNUSED */
cannam@167:      (void)ivs; /* UNUSED */
cannam@167:      return *(const V *)x;
cannam@167: }
cannam@167: 
cannam@167: static inline void STA(R *x, V v, INT ovs, const R *aligned_like)
cannam@167: {
cannam@167:      (void)aligned_like; /* UNUSED */
cannam@167:      (void)ovs; /* UNUSED */
cannam@167:      *(V *)x = v;
cannam@167: }
cannam@167: 
cannam@167: #ifdef FFTW_SINGLE
cannam@167: 
cannam@167: #  ifdef _MSC_VER
cannam@167:      /* Temporarily disable the warning "uninitialized local variable
cannam@167: 	'name' used" and runtime checks for using a variable before it is
cannam@167: 	defined which is erroneously triggered by the LOADL0 / LOADH macros
cannam@167: 	as they only modify VAL partly each. */
cannam@167: #    ifndef __INTEL_COMPILER
cannam@167: #      pragma warning(disable : 4700)
cannam@167: #      pragma runtime_checks("u", off)
cannam@167: #    endif
cannam@167: #  endif
cannam@167: #  ifdef __INTEL_COMPILER
cannam@167: #    pragma warning(disable : 592)
cannam@167: #  endif
cannam@167: 
cannam@167: static inline V LD(const R *x, INT ivs, const R *aligned_like)
cannam@167: {
cannam@167:      V var;
cannam@167:      (void)aligned_like; /* UNUSED */
cannam@167: #  ifdef __GNUC__
cannam@167:      /* We use inline asm because gcc-3.x generates slow code for
cannam@167: 	_mm_loadh_pi().  gcc-3.x insists upon having an existing variable for
cannam@167: 	VAL, which is however never used.  Thus, it generates code to move
cannam@167: 	values in and out the variable.  Worse still, gcc-4.0 stores VAL on
cannam@167: 	the stack, causing valgrind to complain about uninitialized reads. */  
cannam@167:      __asm__("movlps %1, %0\n\tmovhps %2, %0"
cannam@167: 	     : "=x"(var) : "m"(x[0]), "m"(x[ivs]));
cannam@167: #  else
cannam@167: #    define LOADH(addr, val) _mm_loadh_pi(val, (const __m64 *)(addr))
cannam@167: #    define LOADL0(addr, val) _mm_loadl_pi(val, (const __m64 *)(addr))
cannam@167:      var = LOADL0(x, var);
cannam@167:      var = LOADH(x + ivs, var);
cannam@167: #  endif
cannam@167:      return var;
cannam@167: }
cannam@167: 
cannam@167: #  ifdef _MSC_VER
cannam@167: #    ifndef __INTEL_COMPILER
cannam@167: #      pragma warning(default : 4700)
cannam@167: #      pragma runtime_checks("u", restore)
cannam@167: #    endif
cannam@167: #  endif
cannam@167: #  ifdef __INTEL_COMPILER
cannam@167: #    pragma warning(default : 592)
cannam@167: #  endif
cannam@167: 
cannam@167: static inline void ST(R *x, V v, INT ovs, const R *aligned_like)
cannam@167: {
cannam@167:      (void)aligned_like; /* UNUSED */
cannam@167:      /* WARNING: the extra_iter hack depends upon STOREL occurring
cannam@167: 	after STOREH */
cannam@167:      STOREH(x + ovs, v);
cannam@167:      STOREL(x, v);
cannam@167: }
cannam@167: 
cannam@167: #else /* ! FFTW_SINGLE */
cannam@167: #  define LD LDA
cannam@167: #  define ST STA
cannam@167: #endif
cannam@167: 
cannam@167: #define STM2 DS(STA,ST)
cannam@167: #define STN2(x, v0, v1, ovs) /* nop */
cannam@167: 
cannam@167: #ifdef FFTW_SINGLE
cannam@167: #  define STM4(x, v, ovs, aligned_like) /* no-op */
cannam@167: /* STN4 is a macro, not a function, thanks to Visual C++ developers
cannam@167:    deciding "it would be infrequent that people would want to pass more
cannam@167:    than 3 [__m128 parameters] by value."  3 parameters ought to be enough
cannam@167:    for anybody. */
cannam@167: #  define STN4(x, v0, v1, v2, v3, ovs)			\
cannam@167: {							\
cannam@167:      V xxx0, xxx1, xxx2, xxx3;				\
cannam@167:      xxx0 = UNPCKL(v0, v2);				\
cannam@167:      xxx1 = UNPCKH(v0, v2);				\
cannam@167:      xxx2 = UNPCKL(v1, v3);				\
cannam@167:      xxx3 = UNPCKH(v1, v3);				\
cannam@167:      STA(x, UNPCKL(xxx0, xxx2), 0, 0);			\
cannam@167:      STA(x + ovs, UNPCKH(xxx0, xxx2), 0, 0);		\
cannam@167:      STA(x + 2 * ovs, UNPCKL(xxx1, xxx3), 0, 0);	\
cannam@167:      STA(x + 3 * ovs, UNPCKH(xxx1, xxx3), 0, 0);	\
cannam@167: }
cannam@167: #else /* !FFTW_SINGLE */
cannam@167: static inline void STM4(R *x, V v, INT ovs, const R *aligned_like)
cannam@167: {
cannam@167:      (void)aligned_like; /* UNUSED */
cannam@167:      STOREL(x, v);
cannam@167:      STOREH(x + ovs, v);
cannam@167: }
cannam@167: #  define STN4(x, v0, v1, v2, v3, ovs) /* nothing */
cannam@167: #endif
cannam@167: 
cannam@167: static inline V FLIP_RI(V x)
cannam@167: {
cannam@167:      return SHUF(x, x, DS(1, SHUFVALS(1, 0, 3, 2)));
cannam@167: }
cannam@167: 
cannam@167: static inline V VCONJ(V x)
cannam@167: {
cannam@167:      /* This will produce -0.0f (or -0.0d) even on broken
cannam@167:         compilers that do not distinguish +0.0 from -0.0.
cannam@167:         I bet some are still around. */
cannam@167:      union uvec {
cannam@167:           unsigned u[4];
cannam@167:           V v;
cannam@167:      };
cannam@167:      /* it looks like gcc-3.3.5 produces slow code unless PM is
cannam@167:         declared static. */
cannam@167:      static const union uvec pm = {
cannam@167: #ifdef FFTW_SINGLE
cannam@167:           { 0x00000000, 0x80000000, 0x00000000, 0x80000000 }
cannam@167: #else
cannam@167:           { 0x00000000, 0x00000000, 0x00000000, 0x80000000 }
cannam@167: #endif
cannam@167:      };
cannam@167:      return VXOR(pm.v, x);
cannam@167: }
cannam@167: 
cannam@167: static inline V VBYI(V x)
cannam@167: {
cannam@167:      x = VCONJ(x);
cannam@167:      x = FLIP_RI(x);
cannam@167:      return x;
cannam@167: }
cannam@167: 
cannam@167: /* FMA support */
cannam@167: #define VFMA(a, b, c) VADD(c, VMUL(a, b))
cannam@167: #define VFNMS(a, b, c) VSUB(c, VMUL(a, b))
cannam@167: #define VFMS(a, b, c) VSUB(VMUL(a, b), c)
cannam@167: #define VFMAI(b, c) VADD(c, VBYI(b))
cannam@167: #define VFNMSI(b, c) VSUB(c, VBYI(b))
cannam@167: #define VFMACONJ(b,c)  VADD(VCONJ(b),c)
cannam@167: #define VFMSCONJ(b,c)  VSUB(VCONJ(b),c)
cannam@167: #define VFNMSCONJ(b,c) VSUB(c, VCONJ(b))
cannam@167: 
cannam@167: static inline V VZMUL(V tx, V sr)
cannam@167: {
cannam@167:      V tr = VDUPL(tx);
cannam@167:      V ti = VDUPH(tx);
cannam@167:      tr = VMUL(sr, tr);
cannam@167:      sr = VBYI(sr);
cannam@167:      return VFMA(ti, sr, tr);
cannam@167: }
cannam@167: 
cannam@167: static inline V VZMULJ(V tx, V sr)
cannam@167: {
cannam@167:      V tr = VDUPL(tx);
cannam@167:      V ti = VDUPH(tx);
cannam@167:      tr = VMUL(sr, tr);
cannam@167:      sr = VBYI(sr);
cannam@167:      return VFNMS(ti, sr, tr);
cannam@167: }
cannam@167: 
cannam@167: static inline V VZMULI(V tx, V sr)
cannam@167: {
cannam@167:      V tr = VDUPL(tx);
cannam@167:      V ti = VDUPH(tx);
cannam@167:      ti = VMUL(ti, sr);
cannam@167:      sr = VBYI(sr);
cannam@167:      return VFMS(tr, sr, ti);
cannam@167: }
cannam@167: 
cannam@167: static inline V VZMULIJ(V tx, V sr)
cannam@167: {
cannam@167:      V tr = VDUPL(tx);
cannam@167:      V ti = VDUPH(tx);
cannam@167:      ti = VMUL(ti, sr);
cannam@167:      sr = VBYI(sr);
cannam@167:      return VFMA(tr, sr, ti);
cannam@167: }
cannam@167: 
cannam@167: /* twiddle storage #1: compact, slower */
cannam@167: #ifdef FFTW_SINGLE
cannam@167: #  define VTW1(v,x)  \
cannam@167:   {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_SIN, v, x}, {TW_SIN, v+1, x}
cannam@167: static inline V BYTW1(const R *t, V sr)
cannam@167: {
cannam@167:      const V *twp = (const V *)t;
cannam@167:      V tx = twp[0];
cannam@167:      V tr = UNPCKL(tx, tx);
cannam@167:      V ti = UNPCKH(tx, tx);
cannam@167:      tr = VMUL(tr, sr);
cannam@167:      sr = VBYI(sr);
cannam@167:      return VFMA(ti, sr, tr);
cannam@167: }
cannam@167: static inline V BYTWJ1(const R *t, V sr)
cannam@167: {
cannam@167:      const V *twp = (const V *)t;
cannam@167:      V tx = twp[0];
cannam@167:      V tr = UNPCKL(tx, tx);
cannam@167:      V ti = UNPCKH(tx, tx);
cannam@167:      tr = VMUL(tr, sr);
cannam@167:      sr = VBYI(sr);
cannam@167:      return VFNMS(ti, sr, tr);
cannam@167: }
cannam@167: #else /* !FFTW_SINGLE */
cannam@167: #  define VTW1(v,x) {TW_CEXP, v, x}
cannam@167: static inline V BYTW1(const R *t, V sr)
cannam@167: {
cannam@167:      V tx = LD(t, 1, t);
cannam@167:      return VZMUL(tx, sr);
cannam@167: }
cannam@167: static inline V BYTWJ1(const R *t, V sr)
cannam@167: {
cannam@167:      V tx = LD(t, 1, t);
cannam@167:      return VZMULJ(tx, sr);
cannam@167: }
cannam@167: #endif
cannam@167: #define TWVL1 (VL)
cannam@167: 
cannam@167: /* twiddle storage #2: twice the space, faster (when in cache) */
cannam@167: #ifdef FFTW_SINGLE
cannam@167: #  define VTW2(v,x)							\
cannam@167:   {TW_COS, v, x}, {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+1, x},	\
cannam@167:   {TW_SIN, v, -x}, {TW_SIN, v, x}, {TW_SIN, v+1, -x}, {TW_SIN, v+1, x}
cannam@167: #else /* !FFTW_SINGLE */
cannam@167: #  define VTW2(v,x)							\
cannam@167:   {TW_COS, v, x}, {TW_COS, v, x}, {TW_SIN, v, -x}, {TW_SIN, v, x}
cannam@167: #endif
cannam@167: #define TWVL2 (2 * VL)
cannam@167: static inline V BYTW2(const R *t, V sr)
cannam@167: {
cannam@167:      const V *twp = (const V *)t;
cannam@167:      V si = FLIP_RI(sr);
cannam@167:      V tr = twp[0], ti = twp[1];
cannam@167:      return VFMA(tr, sr, VMUL(ti, si));
cannam@167: }
cannam@167: static inline V BYTWJ2(const R *t, V sr)
cannam@167: {
cannam@167:      const V *twp = (const V *)t;
cannam@167:      V si = FLIP_RI(sr);
cannam@167:      V tr = twp[0], ti = twp[1];
cannam@167:      return VFNMS(ti, si, VMUL(tr, sr));
cannam@167: }
cannam@167: 
cannam@167: /* twiddle storage #3 */
cannam@167: #ifdef FFTW_SINGLE
cannam@167: #  define VTW3(v,x) {TW_CEXP, v, x}, {TW_CEXP, v+1, x}
cannam@167: #  define TWVL3 (VL)
cannam@167: #else
cannam@167: #  define VTW3(v,x) VTW1(v,x)
cannam@167: #  define TWVL3 TWVL1
cannam@167: #endif
cannam@167: 
cannam@167: /* twiddle storage for split arrays */
cannam@167: #ifdef FFTW_SINGLE
cannam@167: #  define VTWS(v,x)							  \
cannam@167:     {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_COS, v+2, x}, {TW_COS, v+3, x}, \
cannam@167:     {TW_SIN, v, x}, {TW_SIN, v+1, x}, {TW_SIN, v+2, x}, {TW_SIN, v+3, x}
cannam@167: #else
cannam@167: #  define VTWS(v,x)							  \
cannam@167:     {TW_COS, v, x}, {TW_COS, v+1, x}, {TW_SIN, v, x}, {TW_SIN, v+1, x}
cannam@167: #endif
cannam@167: #define TWVLS (2 * VL)
cannam@167: 
cannam@167: #define VLEAVE() /* nothing */
cannam@167: 
cannam@167: #include "simd-common.h"