/* Optimized with sse2 version of sincosf Copyright (C) 2012-2016 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see . */ #include #define __need_Emath #include /* Short algorithm description: * * 1) if |x|==0: sin(x)=x, * cos(x)=1. * 2) if |x|<2^-27: sin(x)=x-x*DP_SMALL, raising underflow only when needed, * cos(x)=1-|x|. * 3) if |x|<2^-5 : sin(x)=x+x*x^2*DP_SIN2_0+x^5*DP_SIN2_1, * cos(x)=1+1*x^2*DP_COS2_0+x^5*DP_COS2_1 * 4) if |x|< Pi/4: sin(x)=x+x*x^2*(S0+x^2*(S1+x^2*(S2+x^2*(S3+x^2*S4)))), * cos(x)=1+1*x^2*(C0+x^2*(C1+x^2*(C2+x^2*(C3+x^2*C4)))). * 5) if |x| < 9*Pi/4: * 5.1) Range reduction: * k=trunc(|x|/(Pi/4)), j=(k+1)&0x0e, n=k+1, t=|x|-j*Pi/4. * 5.2) Reconstruction: * sign_sin = sign(x) * (-1.0)^(( n >>2)&1) * sign_cos = (-1.0)^(((n+2)>>2)&1) * poly_sin = ((((S4*t^2 + S3)*t^2 + S2)*t^2 + S1)*t^2 + S0)*t^2*t+t * poly_cos = ((((C4*t^2 + C3)*t^2 + C2)*t^2 + C1)*t^2 + C0)*t^2*s+s * if(n&2 != 0) { * using cos(t) and sin(t) polynomials for |t|= 2^23, very large args: * 7.1) Range reduction: * k=trunc(|x|/(Pi/4)), j=(k+1)&0xfffffffe, n=k+1, t=|x|-j*Pi/4. * 7.2) Reconstruction same as (5.2). * 8) if x is Inf, return x-x, and set errno=EDOM. * 9) if x is NaN, return x-x. * * Special cases: * sin/cos(+-0) = +-0/1 not raising inexact/underflow, * sin/cos(subnormal) raises inexact/underflow, * sin/cos(min_normalized) raises inexact/underflow, * sin/cos(normalized) raises inexact, * sin/cos(Inf) = NaN, raises invalid, sets errno to EDOM, * sin/cos(NaN) = NaN. */ #ifdef PIC # define MO1(symbol) L(symbol)##@GOTOFF(%ebx) # define MO2(symbol,reg2,_scale) L(symbol)##@GOTOFF(%ebx,reg2,_scale) # define CFI_PUSH(REG) cfi_adjust_cfa_offset(4); cfi_rel_offset(REG,0) # define CFI_POP(REG) cfi_adjust_cfa_offset(-4); cfi_restore(REG) # define PUSH(REG) pushl REG; CFI_PUSH(REG) # define POP(REG) popl REG; CFI_POP(REG) # define ENTRANCE PUSH(%ebx); LOAD_PIC_REG(bx) # define RETURN POP(%ebx); ret; CFI_PUSH(%ebx) # define ARG_X 8(%esp) # define ARG_SIN_PTR 12(%esp) # define ARG_COS_PTR 16(%esp) #else # define MO1(symbol) L(symbol) # define MO2(symbol,reg2,_scale) L(symbol)(,reg2,_scale) # define ENTRANCE # define RETURN ret # define ARG_X 4(%esp) # define ARG_SIN_PTR 8(%esp) # define ARG_COS_PTR 12(%esp) #endif .text ENTRY(__sincosf_sse2) /* Input: single precision x on stack at address ARG_X */ /* pointer to sin result on stack at address ARG_SIN_PTR */ /* pointer to cos result on stack at address ARG_COS_PTR */ ENTRANCE movl ARG_X, %eax /* Bits of x */ cvtss2sd ARG_X, %xmm0 /* DP x */ andl $0x7fffffff, %eax /* |x| */ cmpl $0x3f490fdb, %eax /* |x|=Pi/4 */ movd %eax, %xmm3 /* SP |x| */ andpd MO1(DP_ABS_MASK),%xmm0 /* DP |x| */ movss MO1(SP_INVPIO4), %xmm2 /* SP 1/(Pi/4) */ cmpl $0x40e231d6, %eax /* |x|<9*Pi/4 ? */ jae L(large_args) /* Here if Pi/4<=|x|<9*Pi/4 */ mulss %xmm3, %xmm2 /* SP |x|/(Pi/4) */ movl ARG_X, %ecx /* Load x */ cvttss2si %xmm2, %eax /* k, number of Pi/4 in x */ shrl $29, %ecx /* (sign of x) << 2 */ addl $1, %eax /* k+1 */ movl $0x0e, %edx andl %eax, %edx /* j = (k+1)&0x0e */ subsd MO2(PIO4J,%edx,8), %xmm0/* t = |x| - j * Pi/4 */ L(reconstruction): /* Input: %eax=n, %xmm0=t, %ecx=sign(x) */ movaps %xmm0, %xmm4 /* t */ movhpd MO1(DP_ONES), %xmm4 /* 1|t */ mulsd %xmm0, %xmm0 /* y=t^2 */ movl $2, %edx unpcklpd %xmm0, %xmm0 /* y|y */ addl %eax, %edx /* k+2 */ movaps %xmm0, %xmm1 /* y|y */ mulpd %xmm0, %xmm0 /* z=t^4|z=t^4 */ movaps MO1(DP_SC4), %xmm2 /* S4 */ mulpd %xmm0, %xmm2 /* z*S4 */ movaps MO1(DP_SC3), %xmm3 /* S3 */ mulpd %xmm0, %xmm3 /* z*S3 */ xorl %eax, %ecx /* (sign_x ^ (k>>2))<<2 */ addpd MO1(DP_SC2), %xmm2 /* S2+z*S4 */ mulpd %xmm0, %xmm2 /* z*(S2+z*S4) */ shrl $2, %edx /* (k+2)>>2 */ addpd MO1(DP_SC1), %xmm3 /* S1+z*S3 */ mulpd %xmm0, %xmm3 /* z*(S1+z*S3) */ shrl $2, %ecx /* sign_x ^ k>>2 */ addpd MO1(DP_SC0), %xmm2 /* S0+z*(S2+z*S4) */ andl $1, %edx /* sign_cos = ((k+2)>>2)&1 */ mulpd %xmm1, %xmm2 /* y*(S0+z*(S2+z*S4)) */ andl $1, %ecx /* sign_sin = sign_x ^ ((k>>2)&1) */ addpd %xmm2, %xmm3 /* y*(S0+y*(S1+y*(S2+y*(S3+y*S4)))) */ mulpd %xmm4, %xmm3 /*t*y*(S0+y*(S1+y*(S2+y*(S3+y*S4))))*/ testl $2, %eax /* n&2 != 0 ? */ addpd %xmm4, %xmm3 /*t+t*y*(S0+y*(S1+y*(S2+y*(S3+y*S4))*/ jnz L(sin_result_sin_poly) /*L(sin_result_cos_poly):*/ /* * Here if * cos(x) = poly_sin * sign_cos * sin(x) = poly_cos * sign_sin */ movsd MO2(DP_ONES,%ecx,8), %xmm4/* 0|sign_sin */ movhpd MO2(DP_ONES,%edx,8), %xmm4/* sign_cos|sign_sin */ mulpd %xmm4, %xmm3 /* result_cos|result_sin */ movl ARG_SIN_PTR, %eax cvtpd2ps %xmm3, %xmm0 /* SP results */ movl ARG_COS_PTR, %ecx movss %xmm0, (%eax) /* store sin(x) from xmm0[0] */ shufps $1, %xmm0, %xmm0 /* move cos(x) to xmm0[0] */ movss %xmm0, (%ecx) /* store cos(x) */ RETURN .p2align 4 L(sin_result_sin_poly): /* * Here if * sin(x) = poly_sin * sign_sin * cos(x) = poly_cos * sign_cos */ movsd MO2(DP_ONES,%edx,8), %xmm4/* 0|sign_cos */ movhpd MO2(DP_ONES,%ecx,8), %xmm4/* sign_sin|sign_cos */ mulpd %xmm4, %xmm3 /* result_sin|result_cos */ movl ARG_SIN_PTR, %eax cvtpd2ps %xmm3, %xmm0 /* SP results */ movl ARG_COS_PTR, %ecx movss %xmm0, (%ecx) /* store cos(x) from xmm0[0] */ shufps $1, %xmm0, %xmm0 /* move sin(x) to xmm0[0] */ movss %xmm0, (%eax) /* store sin(x) */ RETURN .p2align 4 L(large_args): /* Here if |x|>=9*Pi/4 */ cmpl $0x7f800000, %eax /* x is Inf or NaN ? */ jae L(arg_inf_or_nan) /* Here if finite |x|>=9*Pi/4 */ cmpl $0x4b000000, %eax /* |x|<2^23 ? */ jae L(very_large_args) /* Here if 9*Pi/4<=|x|<2^23 */ movsd MO1(DP_INVPIO4), %xmm1 /* 1/(Pi/4) */ mulsd %xmm0, %xmm1 /* |x|/(Pi/4) */ cvttsd2si %xmm1, %eax /* k=trunc(|x|/(Pi/4)) */ addl $1, %eax /* k+1 */ movl %eax, %edx andl $0xfffffffe, %edx /* j=(k+1)&0xfffffffe */ cvtsi2sdl %edx, %xmm4 /* DP j */ movl ARG_X, %ecx /* Load x */ movsd MO1(DP_PIO4HI), %xmm2 /* -PIO4HI = high part of -Pi/4 */ shrl $29, %ecx /* (sign of x) << 2 */ mulsd %xmm4, %xmm2 /* -j*PIO4HI */ movsd MO1(DP_PIO4LO), %xmm3 /* -PIO4LO = low part of -Pi/4 */ addsd %xmm2, %xmm0 /* |x| - j*PIO4HI */ mulsd %xmm3, %xmm4 /* j*PIO4LO */ addsd %xmm4, %xmm0 /* t = |x| - j*PIO4HI - j*PIO4LO */ jmp L(reconstruction) .p2align 4 L(very_large_args): /* Here if finite |x|>=2^23 */ /* bitpos = (ix>>23) - BIAS_32 + 59; */ shrl $23, %eax /* eb = biased exponent of x */ subl $68, %eax /* bitpos=eb-0x7f+59, where 0x7f */ /*is exponent bias */ movl $28, %ecx /* %cl=28 */ movl %eax, %edx /* bitpos copy */ /* j = bitpos/28; */ div %cl /* j in register %al=%ax/%cl */ movapd %xmm0, %xmm3 /* |x| */ andl $0xff, %eax /* clear unneeded remainder from %ah*/ imull $28, %eax, %ecx /* j*28 */ movsd MO1(DP_HI_MASK), %xmm4 /* DP_HI_MASK */ movapd %xmm0, %xmm5 /* |x| */ mulsd -2*8+MO2(_FPI,%eax,8), %xmm3/* tmp3 = FPI[j-2]*|x| */ movapd %xmm0, %xmm1 /* |x| */ mulsd -1*8+MO2(_FPI,%eax,8), %xmm5/* tmp2 = FPI[j-1]*|x| */ mulsd 0*8+MO2(_FPI,%eax,8), %xmm0/* tmp0 = FPI[j]*|x| */ addl $19, %ecx /* j*28+19 */ mulsd 1*8+MO2(_FPI,%eax,8), %xmm1/* tmp1 = FPI[j+1]*|x| */ cmpl %ecx, %edx /* bitpos>=j*28+19 ? */ jl L(very_large_skip1) /* Here if bitpos>=j*28+19 */ andpd %xmm3, %xmm4 /* HI(tmp3) */ subsd %xmm4, %xmm3 /* tmp3 = tmp3 - HI(tmp3) */ L(very_large_skip1): movsd MO1(DP_2POW52), %xmm6 movapd %xmm5, %xmm2 /* tmp2 copy */ addsd %xmm3, %xmm5 /* tmp5 = tmp3 + tmp2 */ movl $1, %edx addsd %xmm5, %xmm6 /* tmp6 = tmp5 + 2^52 */ movsd 8+MO1(DP_2POW52), %xmm4 movd %xmm6, %eax /* k = I64_LO(tmp6); */ addsd %xmm6, %xmm4 /* tmp4 = tmp6 - 2^52 */ movl ARG_X, %ecx /* Load x */ comisd %xmm5, %xmm4 /* tmp4 > tmp5 ? */ jbe L(very_large_skip2) /* Here if tmp4 > tmp5 */ subl $1, %eax /* k-- */ addsd 8+MO1(DP_ONES), %xmm4 /* tmp4 -= 1.0 */ L(very_large_skip2): andl %eax, %edx /* k&1 */ subsd %xmm4, %xmm3 /* tmp3 -= tmp4 */ addsd MO2(DP_ZERONE,%edx,8), %xmm3/* t = DP_ZERONE[k&1] + tmp3 */ addsd %xmm2, %xmm3 /* t += tmp2 */ shrl $29, %ecx /* (sign of x) << 2 */ addsd %xmm3, %xmm0 /* t += tmp0 */ addl $1, %eax /* n=k+1 */ addsd %xmm1, %xmm0 /* t += tmp1 */ mulsd MO1(DP_PIO4), %xmm0 /* t *= PI04 */ jmp L(reconstruction) /* end of very_large_args peth */ .p2align 4 L(arg_less_pio4): /* Here if |x|