GNU Radio 3.6.4.2 C++ API
volk_32fc_x2_conjugate_dot_prod_32fc.h
Go to the documentation of this file.
00001 #ifndef INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_u_H
00002 #define INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_u_H
00003 
00004 
00005 #include<volk/volk_complex.h>
00006 
00007 
00008 #ifdef LV_HAVE_GENERIC
00009 
00010 
00011 static inline void volk_32fc_x2_conjugate_dot_prod_32fc_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
00012 
00013   const unsigned int num_bytes = num_points*8;
00014 
00015   float * res = (float*) result;
00016   float * in = (float*) input;
00017   float * tp = (float*) taps;
00018   unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
00019   unsigned int isodd = (num_bytes >> 3) &1;
00020 
00021 
00022 
00023   float sum0[2] = {0,0};
00024   float sum1[2] = {0,0};
00025   unsigned int i = 0;
00026 
00027 
00028   for(i = 0; i < n_2_ccomplex_blocks; ++i) {
00029 
00030     sum0[0] += in[0] * tp[0] + in[1] * tp[1];
00031     sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];
00032     sum1[0] += in[2] * tp[2] + in[3] * tp[3];
00033     sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];
00034 
00035 
00036     in += 4;
00037     tp += 4;
00038 
00039   }
00040 
00041 
00042   res[0] = sum0[0] + sum1[0];
00043   res[1] = sum0[1] + sum1[1];
00044 
00045 
00046 
00047   for(i = 0; i < isodd; ++i) {
00048 
00049 
00050     *result += input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]);
00051 
00052   }
00053   /*
00054   for(i = 0; i < num_bytes >> 3; ++i) {
00055     *result += input[i] * conjf(taps[i]);
00056   }
00057   */
00058 }
00059 
00060 #endif /*LV_HAVE_GENERIC*/
00061 
00062 #ifdef LV_HAVE_SSE3
00063 
00064 #include <xmmintrin.h>
00065 #include <pmmintrin.h>
00066 #include <mmintrin.h>
00067 
00068 
00069 static inline void volk_32fc_x2_conjugate_dot_prod_32fc_u_sse3(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
00070 
00071   unsigned int num_bytes = num_points*8;
00072 
00073   // Variable never used?
00074   //__VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};
00075 
00076   union HalfMask {
00077     uint32_t intRep[4];
00078     __m128 vec;
00079     } halfMask;
00080 
00081   union NegMask {
00082     int intRep[4];
00083     __m128 vec;
00084   } negMask;
00085 
00086   unsigned int offset = 0;
00087   float Rsum=0, Isum=0;
00088   float Im,Re;
00089 
00090   __m128 in1, in2, Rv, fehg, Iv, Rs, Ivm, Is;
00091   __m128 zv = {0,0,0,0};
00092 
00093   halfMask.intRep[0] = halfMask.intRep[1] = 0xFFFFFFFF;
00094   halfMask.intRep[2] = halfMask.intRep[3] = 0x00000000;
00095 
00096   negMask.intRep[0] = negMask.intRep[2] = 0x80000000;
00097   negMask.intRep[1] = negMask.intRep[3] = 0;
00098 
00099   // main loop
00100   while(num_bytes >= 4*sizeof(float)){
00101 
00102     in1 = _mm_loadu_ps( (float*) (input+offset) );
00103     in2 = _mm_loadu_ps( (float*) (taps+offset) );
00104     Rv = _mm_mul_ps(in1, in2);
00105     fehg = _mm_shuffle_ps(in2, in2, _MM_SHUFFLE(2,3,0,1));
00106     Iv = _mm_mul_ps(in1, fehg);
00107     Rs = _mm_hadd_ps( _mm_hadd_ps(Rv, zv) ,zv);
00108     Ivm = _mm_xor_ps( negMask.vec, Iv );
00109     Is = _mm_hadd_ps( _mm_hadd_ps(Ivm, zv) ,zv);
00110     _mm_store_ss( &Im, Is );
00111     _mm_store_ss( &Re, Rs );
00112     num_bytes -= 4*sizeof(float);
00113     offset += 2;
00114     Rsum += Re;
00115     Isum += Im;
00116   }
00117 
00118   // handle the last complex case ...
00119   if(num_bytes > 0){
00120 
00121     if(num_bytes != 4){
00122       // bad things are happening
00123     }
00124 
00125     in1 = _mm_loadu_ps( (float*) (input+offset) );
00126     in2 = _mm_loadu_ps( (float*) (taps+offset) );
00127     Rv = _mm_and_ps(_mm_mul_ps(in1, in2), halfMask.vec);
00128     fehg = _mm_shuffle_ps(in2, in2, _MM_SHUFFLE(2,3,0,1));
00129     Iv = _mm_and_ps(_mm_mul_ps(in1, fehg), halfMask.vec);
00130     Rs = _mm_hadd_ps(_mm_hadd_ps(Rv, zv),zv);
00131     Ivm = _mm_xor_ps( negMask.vec, Iv );
00132     Is = _mm_hadd_ps(_mm_hadd_ps(Ivm, zv),zv);
00133     _mm_store_ss( &Im, Is );
00134     _mm_store_ss( &Re, Rs );
00135     Rsum += Re;
00136     Isum += Im;
00137   }
00138 
00139   result[0] = lv_cmake(Rsum,Isum);
00140   return;
00141 }
00142 
00143 #endif /*LV_HAVE_SSE3*/
00144 
00145 
00146 #endif /*INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_u_H*/
00147 
00148 
00149 
00150 #ifndef INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_a_H
00151 #define INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_a_H
00152 
00153 #include <volk/volk_common.h>
00154 #include<volk/volk_complex.h>
00155 #include<stdio.h>
00156 
00157 
00158 #ifdef LV_HAVE_GENERIC
00159 
00160 
00161 static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_generic(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
00162 
00163   const unsigned int num_bytes = num_points*8;
00164 
00165   float * res = (float*) result;
00166   float * in = (float*) input;
00167   float * tp = (float*) taps;
00168   unsigned int n_2_ccomplex_blocks = num_bytes >> 4;
00169   unsigned int isodd = (num_bytes >> 3) &1;
00170 
00171 
00172 
00173   float sum0[2] = {0,0};
00174   float sum1[2] = {0,0};
00175   unsigned int i = 0;
00176 
00177 
00178   for(i = 0; i < n_2_ccomplex_blocks; ++i) {
00179 
00180 
00181     sum0[0] += in[0] * tp[0] + in[1] * tp[1];
00182     sum0[1] += (-in[0] * tp[1]) + in[1] * tp[0];
00183     sum1[0] += in[2] * tp[2] + in[3] * tp[3];
00184     sum1[1] += (-in[2] * tp[3]) + in[3] * tp[2];
00185 
00186 
00187     in += 4;
00188     tp += 4;
00189 
00190   }
00191 
00192 
00193   res[0] = sum0[0] + sum1[0];
00194   res[1] = sum0[1] + sum1[1];
00195 
00196 
00197 
00198   for(i = 0; i < isodd; ++i) {
00199 
00200 
00201     *result += input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]);
00202 
00203   }
00204   /*
00205   for(i = 0; i < num_bytes >> 3; ++i) {
00206     *result += input[i] * conjf(taps[i]);
00207   }
00208   */
00209 }
00210 
00211 #endif /*LV_HAVE_GENERIC*/
00212 
00213 
00214 #if LV_HAVE_SSE && LV_HAVE_64
00215 
00216 
00217 static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
00218 
00219   const unsigned int num_bytes = num_points*8;
00220 
00221   __VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};
00222 
00223 
00224 
00225 
00226   asm volatile
00227     (
00228      "#  ccomplex_conjugate_dotprod_generic (float* result, const float *input,\n\t"
00229      "#                         const float *taps, unsigned num_bytes)\n\t"
00230      "#    float sum0 = 0;\n\t"
00231      "#    float sum1 = 0;\n\t"
00232      "#    float sum2 = 0;\n\t"
00233      "#    float sum3 = 0;\n\t"
00234      "#    do {\n\t"
00235      "#      sum0 += input[0] * taps[0] - input[1] * taps[1];\n\t"
00236      "#      sum1 += input[0] * taps[1] + input[1] * taps[0];\n\t"
00237      "#      sum2 += input[2] * taps[2] - input[3] * taps[3];\n\t"
00238      "#      sum3 += input[2] * taps[3] + input[3] * taps[2];\n\t"
00239      "#      input += 4;\n\t"
00240      "#      taps += 4;  \n\t"
00241      "#    } while (--n_2_ccomplex_blocks != 0);\n\t"
00242      "#    result[0] = sum0 + sum2;\n\t"
00243      "#    result[1] = sum1 + sum3;\n\t"
00244      "# TODO: prefetch and better scheduling\n\t"
00245      "  xor    %%r9,  %%r9\n\t"
00246      "  xor    %%r10, %%r10\n\t"
00247      "  movq   %[conjugator], %%r9\n\t"
00248      "  movq   %%rcx, %%rax\n\t"
00249      "  movaps 0(%%r9), %%xmm8\n\t"
00250      "  movq   %%rcx, %%r8\n\t"
00251      "  movq   %[rsi],  %%r9\n\t"
00252      "  movq   %[rdx], %%r10\n\t"
00253      "  xorps   %%xmm6, %%xmm6          # zero accumulators\n\t"
00254      "  movaps  0(%%r9), %%xmm0\n\t"
00255      "  xorps   %%xmm7, %%xmm7          # zero accumulators\n\t"
00256      "  movups  0(%%r10), %%xmm2\n\t"
00257      "  shr     $5, %%rax               # rax = n_2_ccomplex_blocks / 2\n\t"
00258      "  shr     $4, %%r8\n\t"
00259      "  xorps  %%xmm8, %%xmm2\n\t"
00260      "  jmp     .%=L1_test\n\t"
00261      "  # 4 taps / loop\n\t"
00262      "  # something like ?? cycles / loop\n\t"
00263      ".%=Loop1: \n\t"
00264      "# complex prod: C += A * B,  w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
00265      "# movaps  (%%r9), %%xmmA\n\t"
00266      "# movaps  (%%r10), %%xmmB\n\t"
00267      "# movaps  %%xmmA, %%xmmZ\n\t"
00268      "# shufps  $0xb1, %%xmmZ, %%xmmZ   # swap internals\n\t"
00269      "# mulps   %%xmmB, %%xmmA\n\t"
00270      "# mulps   %%xmmZ, %%xmmB\n\t"
00271      "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
00272      "# xorps   %%xmmPN, %%xmmA\n\t"
00273      "# movaps  %%xmmA, %%xmmZ\n\t"
00274      "# unpcklps %%xmmB, %%xmmA\n\t"
00275      "# unpckhps %%xmmB, %%xmmZ\n\t"
00276      "# movaps  %%xmmZ, %%xmmY\n\t"
00277      "# shufps  $0x44, %%xmmA, %%xmmZ   # b01000100\n\t"
00278      "# shufps  $0xee, %%xmmY, %%xmmA   # b11101110\n\t"
00279      "# addps   %%xmmZ, %%xmmA\n\t"
00280      "# addps   %%xmmA, %%xmmC\n\t"
00281      "# A=xmm0, B=xmm2, Z=xmm4\n\t"
00282      "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
00283      "  movaps  16(%%r9), %%xmm1\n\t"
00284      "  movaps  %%xmm0, %%xmm4\n\t"
00285      "  mulps   %%xmm2, %%xmm0\n\t"
00286      "  shufps  $0xb1, %%xmm4, %%xmm4   # swap internals\n\t"
00287      "  movaps  16(%%r10), %%xmm3\n\t"
00288      "  movaps  %%xmm1, %%xmm5\n\t"
00289      "  xorps   %%xmm8, %%xmm3\n\t"
00290      "  addps   %%xmm0, %%xmm6\n\t"
00291      "  mulps   %%xmm3, %%xmm1\n\t"
00292      "  shufps  $0xb1, %%xmm5, %%xmm5   # swap internals\n\t"
00293      "  addps   %%xmm1, %%xmm6\n\t"
00294      "  mulps   %%xmm4, %%xmm2\n\t"
00295      "  movaps  32(%%r9), %%xmm0\n\t"
00296      "  addps   %%xmm2, %%xmm7\n\t"
00297      "  mulps   %%xmm5, %%xmm3\n\t"
00298      "  add     $32, %%r9\n\t"
00299      "  movaps  32(%%r10), %%xmm2\n\t"
00300      "  addps   %%xmm3, %%xmm7\n\t"
00301      "  add     $32, %%r10\n\t"
00302      "  xorps   %%xmm8, %%xmm2\n\t"
00303      ".%=L1_test:\n\t"
00304      "  dec     %%rax\n\t"
00305      "  jge     .%=Loop1\n\t"
00306      "  # We've handled the bulk of multiplies up to here.\n\t"
00307      "  # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
00308      "  # If so, we've got 2 more taps to do.\n\t"
00309      "  and     $1, %%r8\n\t"
00310      "  je      .%=Leven\n\t"
00311      "  # The count was odd, do 2 more taps.\n\t"
00312      "  # Note that we've already got mm0/mm2 preloaded\n\t"
00313      "  # from the main loop.\n\t"
00314      "  movaps  %%xmm0, %%xmm4\n\t"
00315      "  mulps   %%xmm2, %%xmm0\n\t"
00316      "  shufps  $0xb1, %%xmm4, %%xmm4   # swap internals\n\t"
00317      "  addps   %%xmm0, %%xmm6\n\t"
00318      "  mulps   %%xmm4, %%xmm2\n\t"
00319      "  addps   %%xmm2, %%xmm7\n\t"
00320      ".%=Leven:\n\t"
00321      "  # neg inversor\n\t"
00322      "  xorps   %%xmm1, %%xmm1\n\t"
00323      "  mov     $0x80000000, %%r9\n\t"
00324      "  movd    %%r9, %%xmm1\n\t"
00325      "  shufps  $0x11, %%xmm1, %%xmm1   # b00010001 # 0 -0 0 -0\n\t"
00326      "  # pfpnacc\n\t"
00327      "  xorps   %%xmm1, %%xmm6\n\t"
00328      "  movaps  %%xmm6, %%xmm2\n\t"
00329      "  unpcklps %%xmm7, %%xmm6\n\t"
00330      "  unpckhps %%xmm7, %%xmm2\n\t"
00331      "  movaps  %%xmm2, %%xmm3\n\t"
00332      "  shufps  $0x44, %%xmm6, %%xmm2   # b01000100\n\t"
00333      "  shufps  $0xee, %%xmm3, %%xmm6   # b11101110\n\t"
00334      "  addps   %%xmm2, %%xmm6\n\t"
00335      "                                  # xmm6 = r1 i2 r3 i4\n\t"
00336      "  movhlps %%xmm6, %%xmm4          # xmm4 = r3 i4 ?? ??\n\t"
00337      "  addps   %%xmm4, %%xmm6          # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
00338      "  movlps  %%xmm6, (%[rdi])                # store low 2x32 bits (complex) to memory\n\t"
00339      :
00340      :[rsi] "r" (input), [rdx] "r" (taps), "c" (num_bytes), [rdi] "r" (result), [conjugator] "r" (conjugator)
00341      :"rax", "r8", "r9", "r10"
00342      );
00343 
00344 
00345   int getem = num_bytes % 16;
00346 
00347 
00348   for(; getem > 0; getem -= 8) {
00349 
00350 
00351     *result += (input[(num_bytes >> 3) - 1] * lv_conj(taps[(num_bytes >> 3) - 1]));
00352 
00353   }
00354 
00355   return;
00356 }
00357 #endif
00358 
00359 #if LV_HAVE_SSE && LV_HAVE_32
00360 static inline void volk_32fc_x2_conjugate_dot_prod_32fc_a_sse_32(lv_32fc_t* result, const lv_32fc_t* input, const lv_32fc_t* taps, unsigned int num_points) {
00361 
00362   const unsigned int num_bytes = num_points*8;
00363 
00364   __VOLK_ATTR_ALIGNED(16) static const uint32_t conjugator[4]= {0x00000000, 0x80000000, 0x00000000, 0x80000000};
00365 
00366   int bound = num_bytes >> 4;
00367   int leftovers = num_bytes % 16;
00368 
00369 
00370   asm volatile
00371     (
00372      "  #pushl  %%ebp\n\t"
00373      "  #movl   %%esp, %%ebp\n\t"
00374      "  #movl   12(%%ebp), %%eax                # input\n\t"
00375      "  #movl   16(%%ebp), %%edx                # taps\n\t"
00376      "  #movl   20(%%ebp), %%ecx                # n_bytes\n\t"
00377      "  movaps  0(%[conjugator]), %%xmm1\n\t"
00378      "  xorps   %%xmm6, %%xmm6          # zero accumulators\n\t"
00379      "  movaps  0(%[eax]), %%xmm0\n\t"
00380      "  xorps   %%xmm7, %%xmm7          # zero accumulators\n\t"
00381      "  movaps  0(%[edx]), %%xmm2\n\t"
00382      "  movl    %[ecx], (%[out])\n\t"
00383      "  shrl    $5, %[ecx]              # ecx = n_2_ccomplex_blocks / 2\n\t"
00384 
00385      "  xorps   %%xmm1, %%xmm2\n\t"
00386      "  jmp     .%=L1_test\n\t"
00387      "  # 4 taps / loop\n\t"
00388      "  # something like ?? cycles / loop\n\t"
00389      ".%=Loop1: \n\t"
00390      "# complex prod: C += A * B,  w/ temp Z & Y (or B), xmmPN=$0x8000000080000000\n\t"
00391      "# movaps  (%[eax]), %%xmmA\n\t"
00392      "# movaps  (%[edx]), %%xmmB\n\t"
00393      "# movaps  %%xmmA, %%xmmZ\n\t"
00394      "# shufps  $0xb1, %%xmmZ, %%xmmZ   # swap internals\n\t"
00395      "# mulps   %%xmmB, %%xmmA\n\t"
00396      "# mulps   %%xmmZ, %%xmmB\n\t"
00397      "# # SSE replacement for: pfpnacc %%xmmB, %%xmmA\n\t"
00398      "# xorps   %%xmmPN, %%xmmA\n\t"
00399      "# movaps  %%xmmA, %%xmmZ\n\t"
00400      "# unpcklps %%xmmB, %%xmmA\n\t"
00401      "# unpckhps %%xmmB, %%xmmZ\n\t"
00402      "# movaps  %%xmmZ, %%xmmY\n\t"
00403      "# shufps  $0x44, %%xmmA, %%xmmZ   # b01000100\n\t"
00404      "# shufps  $0xee, %%xmmY, %%xmmA   # b11101110\n\t"
00405      "# addps   %%xmmZ, %%xmmA\n\t"
00406      "# addps   %%xmmA, %%xmmC\n\t"
00407      "# A=xmm0, B=xmm2, Z=xmm4\n\t"
00408      "# A'=xmm1, B'=xmm3, Z'=xmm5\n\t"
00409      "  movaps  16(%[edx]), %%xmm3\n\t"
00410      "  movaps  %%xmm0, %%xmm4\n\t"
00411      "  xorps   %%xmm1, %%xmm3\n\t"
00412      "  mulps   %%xmm2, %%xmm0\n\t"
00413      "  movaps  16(%[eax]), %%xmm1\n\t"
00414      "  shufps  $0xb1, %%xmm4, %%xmm4   # swap internals\n\t"
00415      "  movaps  %%xmm1, %%xmm5\n\t"
00416      "  addps   %%xmm0, %%xmm6\n\t"
00417      "  mulps   %%xmm3, %%xmm1\n\t"
00418      "  shufps  $0xb1, %%xmm5, %%xmm5   # swap internals\n\t"
00419      "  addps   %%xmm1, %%xmm6\n\t"
00420      "  movaps  0(%[conjugator]), %%xmm1\n\t"
00421      "  mulps   %%xmm4, %%xmm2\n\t"
00422      "  movaps  32(%[eax]), %%xmm0\n\t"
00423      "  addps   %%xmm2, %%xmm7\n\t"
00424      "  mulps   %%xmm5, %%xmm3\n\t"
00425      "  addl    $32, %[eax]\n\t"
00426      "  movaps  32(%[edx]), %%xmm2\n\t"
00427      "  addps   %%xmm3, %%xmm7\n\t"
00428      "  xorps   %%xmm1, %%xmm2\n\t"
00429      "  addl    $32, %[edx]\n\t"
00430      ".%=L1_test:\n\t"
00431      "  decl    %[ecx]\n\t"
00432      "  jge     .%=Loop1\n\t"
00433      "  # We've handled the bulk of multiplies up to here.\n\t"
00434      "  # Let's sse if original n_2_ccomplex_blocks was odd.\n\t"
00435      "  # If so, we've got 2 more taps to do.\n\t"
00436      "  movl    0(%[out]), %[ecx]               # n_2_ccomplex_blocks\n\t"
00437      "  shrl    $4, %[ecx]\n\t"
00438      "  andl    $1, %[ecx]\n\t"
00439      "  je      .%=Leven\n\t"
00440      "  # The count was odd, do 2 more taps.\n\t"
00441      "  # Note that we've already got mm0/mm2 preloaded\n\t"
00442      "  # from the main loop.\n\t"
00443      "  movaps  %%xmm0, %%xmm4\n\t"
00444      "  mulps   %%xmm2, %%xmm0\n\t"
00445      "  shufps  $0xb1, %%xmm4, %%xmm4   # swap internals\n\t"
00446      "  addps   %%xmm0, %%xmm6\n\t"
00447      "  mulps   %%xmm4, %%xmm2\n\t"
00448      "  addps   %%xmm2, %%xmm7\n\t"
00449      ".%=Leven:\n\t"
00450      "  # neg inversor\n\t"
00451      "  #movl 8(%%ebp), %[eax] \n\t"
00452      "  xorps   %%xmm1, %%xmm1\n\t"
00453      "  movl    $0x80000000, (%[out])\n\t"
00454      "  movss   (%[out]), %%xmm1\n\t"
00455      "  shufps  $0x11, %%xmm1, %%xmm1   # b00010001 # 0 -0 0 -0\n\t"
00456      "  # pfpnacc\n\t"
00457      "  xorps   %%xmm1, %%xmm6\n\t"
00458      "  movaps  %%xmm6, %%xmm2\n\t"
00459      "  unpcklps %%xmm7, %%xmm6\n\t"
00460      "  unpckhps %%xmm7, %%xmm2\n\t"
00461      "  movaps  %%xmm2, %%xmm3\n\t"
00462      "  shufps  $0x44, %%xmm6, %%xmm2   # b01000100\n\t"
00463      "  shufps  $0xee, %%xmm3, %%xmm6   # b11101110\n\t"
00464      "  addps   %%xmm2, %%xmm6\n\t"
00465      "                                  # xmm6 = r1 i2 r3 i4\n\t"
00466      "  #movl   8(%%ebp), %[eax]                # @result\n\t"
00467      "  movhlps %%xmm6, %%xmm4          # xmm4 = r3 i4 ?? ??\n\t"
00468      "  addps   %%xmm4, %%xmm6          # xmm6 = r1+r3 i2+i4 ?? ??\n\t"
00469      "  movlps  %%xmm6, (%[out])                # store low 2x32 bits (complex) to memory\n\t"
00470      "  #popl   %%ebp\n\t"
00471      :
00472      : [eax] "r" (input), [edx] "r" (taps), [ecx] "r" (num_bytes), [out] "r" (result), [conjugator] "r" (conjugator)
00473      );
00474 
00475 
00476 
00477 
00478   printf("%d, %d\n", leftovers, bound);
00479 
00480   for(; leftovers > 0; leftovers -= 8) {
00481 
00482 
00483     *result += (input[(bound << 1)] * lv_conj(taps[(bound << 1)]));
00484 
00485   }
00486 
00487   return;
00488 
00489 
00490 
00491 
00492 
00493 
00494 }
00495 
00496 #endif /*LV_HAVE_SSE*/
00497 
00498 
00499 
00500 #endif /*INCLUDED_volk_32fc_x2_conjugate_dot_prod_32fc_a_H*/