2 * msvcrt.dll math functions
4 * Copyright 2000 Jon Griffiths
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #define __USE_ISOC9X 1
24 #define __USE_ISOC99 1
32 #include "wine/debug.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt
);
37 #ifndef finite /* Could be a macro */
39 #define finite(x) isfinite(x)
41 #define finite(x) (!isnan(x)) /* At least catch some cases */
50 typedef int (CDECL
*MSVCRT_matherr_func
)(struct MSVCRT__exception
*);
52 static MSVCRT_matherr_func MSVCRT_default_matherr_func
= NULL
;
54 static BOOL sse2_supported
;
55 static BOOL sse2_enabled
;
57 void msvcrt_init_math(void)
59 sse2_supported
= sse2_enabled
= IsProcessorFeaturePresent( PF_XMMI64_INSTRUCTIONS_AVAILABLE
);
62 /*********************************************************************
63 * _set_SSE2_enable (MSVCRT.@)
65 int CDECL
MSVCRT__set_SSE2_enable(int flag
)
67 sse2_enabled
= flag
&& sse2_supported
;
73 /*********************************************************************
74 * _chgsignf (MSVCRT.@)
76 float CDECL
MSVCRT__chgsignf( float num
)
78 /* FIXME: +-infinity,Nan not tested */
82 /*********************************************************************
83 * _copysignf (MSVCRT.@)
85 float CDECL
MSVCRT__copysignf( float num
, float sign
)
87 /* FIXME: Behaviour for Nan/Inf? */
89 return num
< 0.0 ? num
: -num
;
90 return num
< 0.0 ? -num
: num
;
93 /*********************************************************************
96 int CDECL
MSVCRT__finitef( float num
)
98 return finitef(num
) != 0; /* See comment for _isnan() */
101 /*********************************************************************
104 INT CDECL
MSVCRT__isnanf( float num
)
106 /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
107 * Do the same, as the result may be used in calculations
109 return isnanf(num
) != 0;
112 /*********************************************************************
115 float CDECL
MSVCRT__logbf( float num
)
117 if (!finitef(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
121 /*********************************************************************
122 * _nextafterf (MSVCRT.@)
124 float CDECL
MSVCRT__nextafterf( float num
, float next
)
126 if (!finitef(num
) || !finitef(next
)) *MSVCRT__errno() = MSVCRT_EDOM
;
127 return nextafterf( num
, next
);
130 /*********************************************************************
131 * MSVCRT_acosf (MSVCRT.@)
133 float CDECL
MSVCRT_acosf( float x
)
135 if (x
< -1.0 || x
> 1.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
136 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
137 * asin() uses a similar construction. This is bad because as x gets nearer to
138 * 1 the error in the expression "1 - x^2" can get relatively large due to
139 * cancellation. The sqrt() makes things worse. A safer way to calculate
140 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
141 return atan2f(sqrtf((1 - x
) * (1 + x
)), x
);
144 /*********************************************************************
145 * MSVCRT_asinf (MSVCRT.@)
147 float CDECL
MSVCRT_asinf( float x
)
149 if (x
< -1.0 || x
> 1.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
150 return atan2f(x
, sqrtf((1 - x
) * (1 + x
)));
153 /*********************************************************************
154 * MSVCRT_atanf (MSVCRT.@)
156 float CDECL
MSVCRT_atanf( float x
)
158 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
162 /*********************************************************************
163 * MSVCRT_atan2f (MSVCRT.@)
165 float CDECL
MSVCRT_atan2f( float x
, float y
)
167 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
171 /*********************************************************************
172 * MSVCRT_cosf (MSVCRT.@)
174 float CDECL
MSVCRT_cosf( float x
)
176 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
180 /*********************************************************************
181 * MSVCRT_coshf (MSVCRT.@)
183 float CDECL
MSVCRT_coshf( float x
)
185 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
189 /*********************************************************************
190 * MSVCRT_expf (MSVCRT.@)
192 float CDECL
MSVCRT_expf( float x
)
194 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
198 /*********************************************************************
199 * MSVCRT_fmodf (MSVCRT.@)
201 float CDECL
MSVCRT_fmodf( float x
, float y
)
203 if (!finitef(x
) || !finitef(y
)) *MSVCRT__errno() = MSVCRT_EDOM
;
207 /*********************************************************************
208 * MSVCRT_logf (MSVCRT.@)
210 float CDECL
MSVCRT_logf( float x
)
212 if (x
< 0.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
213 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
217 /*********************************************************************
218 * MSVCRT_log10f (MSVCRT.@)
220 float CDECL
MSVCRT_log10f( float x
)
222 if (x
< 0.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
223 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
227 /*********************************************************************
228 * MSVCRT_powf (MSVCRT.@)
230 float CDECL
MSVCRT_powf( float x
, float y
)
232 /* FIXME: If x < 0 and y is not integral, set EDOM */
234 if (!finitef(z
)) *MSVCRT__errno() = MSVCRT_EDOM
;
238 /*********************************************************************
239 * MSVCRT_sinf (MSVCRT.@)
241 float CDECL
MSVCRT_sinf( float x
)
243 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
247 /*********************************************************************
248 * MSVCRT_sinhf (MSVCRT.@)
250 float CDECL
MSVCRT_sinhf( float x
)
252 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
256 /*********************************************************************
257 * MSVCRT_sqrtf (MSVCRT.@)
259 float CDECL
MSVCRT_sqrtf( float x
)
261 if (x
< 0.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
265 /*********************************************************************
266 * MSVCRT_tanf (MSVCRT.@)
268 float CDECL
MSVCRT_tanf( float x
)
270 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
274 /*********************************************************************
275 * MSVCRT_tanhf (MSVCRT.@)
277 float CDECL
MSVCRT_tanhf( float x
)
279 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
283 /*********************************************************************
286 float CDECL
MSVCRT_ceilf( float x
)
291 /*********************************************************************
294 float CDECL
MSVCRT_floorf( float x
)
299 /*********************************************************************
302 float CDECL
MSVCRT_frexpf( float x
, int *exp
)
304 return frexpf( x
, exp
);
307 /*********************************************************************
310 float CDECL
MSVCRT__scalbf(float num
, MSVCRT_long power
)
312 if (!finitef(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
313 return ldexpf(num
, power
);
316 /*********************************************************************
319 double CDECL
MSVCRT_modff( float x
, float *iptr
)
321 return modff( x
, iptr
);
326 /*********************************************************************
327 * MSVCRT_acos (MSVCRT.@)
329 double CDECL
MSVCRT_acos( double x
)
331 if (x
< -1.0 || x
> 1.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
332 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
333 * asin() uses a similar construction. This is bad because as x gets nearer to
334 * 1 the error in the expression "1 - x^2" can get relatively large due to
335 * cancellation. The sqrt() makes things worse. A safer way to calculate
336 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
337 return atan2(sqrt((1 - x
) * (1 + x
)), x
);
340 /*********************************************************************
341 * MSVCRT_asin (MSVCRT.@)
343 double CDECL
MSVCRT_asin( double x
)
345 if (x
< -1.0 || x
> 1.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
346 return atan2(x
, sqrt((1 - x
) * (1 + x
)));
349 /*********************************************************************
350 * MSVCRT_atan (MSVCRT.@)
352 double CDECL
MSVCRT_atan( double x
)
354 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
358 /*********************************************************************
359 * MSVCRT_atan2 (MSVCRT.@)
361 double CDECL
MSVCRT_atan2( double x
, double y
)
363 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
367 /*********************************************************************
368 * MSVCRT_cos (MSVCRT.@)
370 double CDECL
MSVCRT_cos( double x
)
372 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
376 /*********************************************************************
377 * MSVCRT_cosh (MSVCRT.@)
379 double CDECL
MSVCRT_cosh( double x
)
381 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
385 /*********************************************************************
386 * MSVCRT_exp (MSVCRT.@)
388 double CDECL
MSVCRT_exp( double x
)
390 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
394 /*********************************************************************
395 * MSVCRT_fmod (MSVCRT.@)
397 double CDECL
MSVCRT_fmod( double x
, double y
)
399 if (!finite(x
) || !finite(y
)) *MSVCRT__errno() = MSVCRT_EDOM
;
403 /*********************************************************************
404 * MSVCRT_log (MSVCRT.@)
406 double CDECL
MSVCRT_log( double x
)
408 if (x
< 0.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
409 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
413 /*********************************************************************
414 * MSVCRT_log10 (MSVCRT.@)
416 double CDECL
MSVCRT_log10( double x
)
418 if (x
< 0.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
419 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
423 /*********************************************************************
424 * MSVCRT_pow (MSVCRT.@)
426 double CDECL
MSVCRT_pow( double x
, double y
)
428 /* FIXME: If x < 0 and y is not integral, set EDOM */
430 if (!finite(z
)) *MSVCRT__errno() = MSVCRT_EDOM
;
434 /*********************************************************************
435 * MSVCRT_sin (MSVCRT.@)
437 double CDECL
MSVCRT_sin( double x
)
439 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
443 /*********************************************************************
444 * MSVCRT_sinh (MSVCRT.@)
446 double CDECL
MSVCRT_sinh( double x
)
448 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
452 /*********************************************************************
453 * MSVCRT_sqrt (MSVCRT.@)
455 double CDECL
MSVCRT_sqrt( double x
)
457 if (x
< 0.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
461 /*********************************************************************
462 * MSVCRT_tan (MSVCRT.@)
464 double CDECL
MSVCRT_tan( double x
)
466 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
470 /*********************************************************************
471 * MSVCRT_tanh (MSVCRT.@)
473 double CDECL
MSVCRT_tanh( double x
)
475 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
480 #if defined(__GNUC__) && defined(__i386__)
482 #define FPU_DOUBLE(var) double var; \
483 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
484 #define FPU_DOUBLES(var1,var2) double var1,var2; \
485 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
486 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
488 /*********************************************************************
491 double CDECL
_CIacos(void)
494 return MSVCRT_acos(x
);
497 /*********************************************************************
500 double CDECL
_CIasin(void)
503 return MSVCRT_asin(x
);
506 /*********************************************************************
509 double CDECL
_CIatan(void)
512 return MSVCRT_atan(x
);
515 /*********************************************************************
516 * _CIatan2 (MSVCRT.@)
518 double CDECL
_CIatan2(void)
521 return MSVCRT_atan2(x
,y
);
524 /*********************************************************************
527 double CDECL
_CIcos(void)
530 return MSVCRT_cos(x
);
533 /*********************************************************************
536 double CDECL
_CIcosh(void)
539 return MSVCRT_cosh(x
);
542 /*********************************************************************
545 double CDECL
_CIexp(void)
548 return MSVCRT_exp(x
);
551 /*********************************************************************
554 double CDECL
_CIfmod(void)
557 return MSVCRT_fmod(x
,y
);
560 /*********************************************************************
563 double CDECL
_CIlog(void)
566 return MSVCRT_log(x
);
569 /*********************************************************************
570 * _CIlog10 (MSVCRT.@)
572 double CDECL
_CIlog10(void)
575 return MSVCRT_log10(x
);
578 /*********************************************************************
581 double CDECL
_CIpow(void)
584 return MSVCRT_pow(x
,y
);
587 /*********************************************************************
590 double CDECL
_CIsin(void)
593 return MSVCRT_sin(x
);
596 /*********************************************************************
599 double CDECL
_CIsinh(void)
602 return MSVCRT_sinh(x
);
605 /*********************************************************************
608 double CDECL
_CIsqrt(void)
611 return MSVCRT_sqrt(x
);
614 /*********************************************************************
617 double CDECL
_CItan(void)
620 return MSVCRT_tan(x
);
623 /*********************************************************************
626 double CDECL
_CItanh(void)
629 return MSVCRT_tanh(x
);
632 #endif /* defined(__GNUC__) && defined(__i386__) */
634 /*********************************************************************
635 * _fpclass (MSVCRT.@)
637 int CDECL
MSVCRT__fpclass(double num
)
639 #if defined(HAVE_FPCLASS) || defined(fpclass)
640 switch (fpclass( num
))
643 case FP_SNAN
: return MSVCRT__FPCLASS_SNAN
;
646 case FP_QNAN
: return MSVCRT__FPCLASS_QNAN
;
649 case FP_NINF
: return MSVCRT__FPCLASS_NINF
;
652 case FP_PINF
: return MSVCRT__FPCLASS_PINF
;
655 case FP_NDENORM
: return MSVCRT__FPCLASS_ND
;
658 case FP_PDENORM
: return MSVCRT__FPCLASS_PD
;
661 case FP_NZERO
: return MSVCRT__FPCLASS_NZ
;
664 case FP_PZERO
: return MSVCRT__FPCLASS_PZ
;
667 case FP_NNORM
: return MSVCRT__FPCLASS_NN
;
670 case FP_PNORM
: return MSVCRT__FPCLASS_PN
;
672 default: return MSVCRT__FPCLASS_PN
;
674 #elif defined (fpclassify)
675 switch (fpclassify( num
))
677 case FP_NAN
: return MSVCRT__FPCLASS_QNAN
;
678 case FP_INFINITE
: return signbit(num
) ? MSVCRT__FPCLASS_NINF
: MSVCRT__FPCLASS_PINF
;
679 case FP_SUBNORMAL
: return signbit(num
) ?MSVCRT__FPCLASS_ND
: MSVCRT__FPCLASS_PD
;
680 case FP_ZERO
: return signbit(num
) ? MSVCRT__FPCLASS_NZ
: MSVCRT__FPCLASS_PZ
;
682 return signbit(num
) ? MSVCRT__FPCLASS_NN
: MSVCRT__FPCLASS_PN
;
685 return MSVCRT__FPCLASS_QNAN
;
686 return num
== 0.0 ? MSVCRT__FPCLASS_PZ
: (num
< 0 ? MSVCRT__FPCLASS_NN
: MSVCRT__FPCLASS_PN
);
690 /*********************************************************************
693 unsigned int CDECL
_rotl(unsigned int num
, int shift
)
696 return (num
<< shift
) | (num
>> (32-shift
));
699 /*********************************************************************
702 MSVCRT_ulong CDECL
MSVCRT__lrotl(MSVCRT_ulong num
, int shift
)
705 return (num
<< shift
) | (num
>> (32-shift
));
708 /*********************************************************************
711 MSVCRT_ulong CDECL
MSVCRT__lrotr(MSVCRT_ulong num
, int shift
)
714 return (num
>> shift
) | (num
<< (32-shift
));
717 /*********************************************************************
720 unsigned int CDECL
_rotr(unsigned int num
, int shift
)
723 return (num
>> shift
) | (num
<< (32-shift
));
726 /*********************************************************************
729 unsigned __int64 CDECL
_rotl64(unsigned __int64 num
, int shift
)
732 return (num
<< shift
) | (num
>> (64-shift
));
735 /*********************************************************************
738 unsigned __int64 CDECL
_rotr64(unsigned __int64 num
, int shift
)
741 return (num
>> shift
) | (num
<< (64-shift
));
744 /*********************************************************************
747 int CDECL
MSVCRT_abs( int n
)
749 return n
>= 0 ? n
: -n
;
752 /*********************************************************************
755 MSVCRT_long CDECL
MSVCRT_labs( MSVCRT_long n
)
757 return n
>= 0 ? n
: -n
;
760 /*********************************************************************
763 __int64 CDECL
_abs64( __int64 n
)
765 return n
>= 0 ? n
: -n
;
768 /*********************************************************************
771 double CDECL
MSVCRT__logb(double num
)
773 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
777 /*********************************************************************
780 double CDECL
MSVCRT__scalb(double num
, MSVCRT_long power
)
782 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
783 return ldexp(num
, power
);
786 /*********************************************************************
789 double CDECL
_hypot(double x
, double y
)
791 /* FIXME: errno handling */
792 return hypot( x
, y
);
795 /*********************************************************************
798 float CDECL
MSVCRT__hypotf(float x
, float y
)
800 /* FIXME: errno handling */
801 return hypotf( x
, y
);
804 /*********************************************************************
807 double CDECL
MSVCRT_ceil( double x
)
812 /*********************************************************************
815 double CDECL
MSVCRT_floor( double x
)
820 /*********************************************************************
823 double CDECL
MSVCRT_fabs( double x
)
828 /*********************************************************************
831 double CDECL
MSVCRT_frexp( double x
, int *exp
)
833 return frexp( x
, exp
);
836 /*********************************************************************
839 double CDECL
MSVCRT_modf( double x
, double *iptr
)
841 return modf( x
, iptr
);
844 /*********************************************************************
845 * _matherr (MSVCRT.@)
847 int CDECL
MSVCRT__matherr(struct MSVCRT__exception
*e
)
850 TRACE("(%p = %d, %s, %g %g %g)\n",e
, e
->type
, e
->name
, e
->arg1
, e
->arg2
,
854 if (MSVCRT_default_matherr_func
)
855 return MSVCRT_default_matherr_func(e
);
856 ERR(":Unhandled math error!\n");
860 /*********************************************************************
861 * __setusermatherr (MSVCRT.@)
863 void CDECL
MSVCRT___setusermatherr(MSVCRT_matherr_func func
)
865 MSVCRT_default_matherr_func
= func
;
866 TRACE(":new matherr handler %p\n", func
);
869 /**********************************************************************
870 * _statusfp2 (MSVCRT.@)
872 * Not exported by native msvcrt, added in msvcr80.
874 #if defined(__i386__) || defined(__x86_64__)
875 void CDECL
_statusfp2( unsigned int *x86_sw
, unsigned int *sse2_sw
)
879 unsigned long fpword
;
883 __asm__
__volatile__( "fstsw %0" : "=m" (fpword
) );
885 if (fpword
& 0x1) flags
|= MSVCRT__SW_INVALID
;
886 if (fpword
& 0x2) flags
|= MSVCRT__SW_DENORMAL
;
887 if (fpword
& 0x4) flags
|= MSVCRT__SW_ZERODIVIDE
;
888 if (fpword
& 0x8) flags
|= MSVCRT__SW_OVERFLOW
;
889 if (fpword
& 0x10) flags
|= MSVCRT__SW_UNDERFLOW
;
890 if (fpword
& 0x20) flags
|= MSVCRT__SW_INEXACT
;
894 if (!sse2_sw
) return;
898 __asm__
__volatile__( "stmxcsr %0" : "=m" (fpword
) );
900 if (fpword
& 0x1) flags
|= MSVCRT__SW_INVALID
;
901 if (fpword
& 0x2) flags
|= MSVCRT__SW_DENORMAL
;
902 if (fpword
& 0x4) flags
|= MSVCRT__SW_ZERODIVIDE
;
903 if (fpword
& 0x8) flags
|= MSVCRT__SW_OVERFLOW
;
904 if (fpword
& 0x10) flags
|= MSVCRT__SW_UNDERFLOW
;
905 if (fpword
& 0x20) flags
|= MSVCRT__SW_INEXACT
;
910 FIXME( "not implemented\n" );
915 /**********************************************************************
916 * _statusfp (MSVCRT.@)
918 unsigned int CDECL
_statusfp(void)
920 #if defined(__i386__) || defined(__x86_64__)
921 unsigned int x86_sw
, sse2_sw
;
923 _statusfp2( &x86_sw
, &sse2_sw
);
924 /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
925 return x86_sw
| sse2_sw
;
927 FIXME( "not implemented\n" );
932 /*********************************************************************
933 * _clearfp (MSVCRT.@)
935 unsigned int CDECL
_clearfp(void)
937 unsigned int flags
= 0;
938 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
939 unsigned long fpword
;
941 __asm__
__volatile__( "fnstsw %0; fnclex" : "=m" (fpword
) );
942 if (fpword
& 0x1) flags
|= MSVCRT__SW_INVALID
;
943 if (fpword
& 0x2) flags
|= MSVCRT__SW_DENORMAL
;
944 if (fpword
& 0x4) flags
|= MSVCRT__SW_ZERODIVIDE
;
945 if (fpword
& 0x8) flags
|= MSVCRT__SW_OVERFLOW
;
946 if (fpword
& 0x10) flags
|= MSVCRT__SW_UNDERFLOW
;
947 if (fpword
& 0x20) flags
|= MSVCRT__SW_INEXACT
;
951 __asm__
__volatile__( "stmxcsr %0" : "=m" (fpword
) );
952 if (fpword
& 0x1) flags
|= MSVCRT__SW_INVALID
;
953 if (fpword
& 0x2) flags
|= MSVCRT__SW_DENORMAL
;
954 if (fpword
& 0x4) flags
|= MSVCRT__SW_ZERODIVIDE
;
955 if (fpword
& 0x8) flags
|= MSVCRT__SW_OVERFLOW
;
956 if (fpword
& 0x10) flags
|= MSVCRT__SW_UNDERFLOW
;
957 if (fpword
& 0x20) flags
|= MSVCRT__SW_INEXACT
;
959 __asm__
__volatile__( "ldmxcsr %0" : : "m" (fpword
) );
962 FIXME( "not implemented\n" );
967 /*********************************************************************
968 * __fpecode (MSVCRT.@)
970 int * CDECL
__fpecode(void)
972 return &msvcrt_get_thread_data()->fpecode
;
975 /*********************************************************************
978 double CDECL
MSVCRT_ldexp(double num
, MSVCRT_long exp
)
980 double z
= ldexp(num
,exp
);
983 *MSVCRT__errno() = MSVCRT_ERANGE
;
984 else if (z
== 0 && signbit(z
))
985 z
= 0.0; /* Convert -0 -> +0 */
989 /*********************************************************************
992 double CDECL
MSVCRT__cabs(struct MSVCRT__complex num
)
994 return sqrt(num
.x
* num
.x
+ num
.y
* num
.y
);
997 /*********************************************************************
998 * _chgsign (MSVCRT.@)
1000 double CDECL
MSVCRT__chgsign(double num
)
1002 /* FIXME: +-infinity,Nan not tested */
1006 /*********************************************************************
1007 * __control87_2 (MSVCRT.@)
1009 * Not exported by native msvcrt, added in msvcr80.
1011 #if defined(__i386__) || defined(__x86_64__)
1012 int CDECL
__control87_2( unsigned int newval
, unsigned int mask
,
1013 unsigned int *x86_cw
, unsigned int *sse2_cw
)
1016 unsigned long fpword
;
1021 __asm__
__volatile__( "fstcw %0" : "=m" (fpword
) );
1023 /* Convert into mask constants */
1025 if (fpword
& 0x1) flags
|= MSVCRT__EM_INVALID
;
1026 if (fpword
& 0x2) flags
|= MSVCRT__EM_DENORMAL
;
1027 if (fpword
& 0x4) flags
|= MSVCRT__EM_ZERODIVIDE
;
1028 if (fpword
& 0x8) flags
|= MSVCRT__EM_OVERFLOW
;
1029 if (fpword
& 0x10) flags
|= MSVCRT__EM_UNDERFLOW
;
1030 if (fpword
& 0x20) flags
|= MSVCRT__EM_INEXACT
;
1031 switch (fpword
& 0xc00)
1033 case 0xc00: flags
|= MSVCRT__RC_UP
|MSVCRT__RC_DOWN
; break;
1034 case 0x800: flags
|= MSVCRT__RC_UP
; break;
1035 case 0x400: flags
|= MSVCRT__RC_DOWN
; break;
1037 switch (fpword
& 0x300)
1039 case 0x0: flags
|= MSVCRT__PC_24
; break;
1040 case 0x200: flags
|= MSVCRT__PC_53
; break;
1041 case 0x300: flags
|= MSVCRT__PC_64
; break;
1043 if (fpword
& 0x1000) flags
|= MSVCRT__IC_AFFINE
;
1045 TRACE( "x86 flags=%08x newval=%08x mask=%08x\n", flags
, newval
, mask
);
1048 flags
= (flags
& ~mask
) | (newval
& mask
);
1050 /* Convert (masked) value back to fp word */
1052 if (flags
& MSVCRT__EM_INVALID
) fpword
|= 0x1;
1053 if (flags
& MSVCRT__EM_DENORMAL
) fpword
|= 0x2;
1054 if (flags
& MSVCRT__EM_ZERODIVIDE
) fpword
|= 0x4;
1055 if (flags
& MSVCRT__EM_OVERFLOW
) fpword
|= 0x8;
1056 if (flags
& MSVCRT__EM_UNDERFLOW
) fpword
|= 0x10;
1057 if (flags
& MSVCRT__EM_INEXACT
) fpword
|= 0x20;
1058 switch (flags
& MSVCRT__MCW_RC
)
1060 case MSVCRT__RC_UP
|MSVCRT__RC_DOWN
: fpword
|= 0xc00; break;
1061 case MSVCRT__RC_UP
: fpword
|= 0x800; break;
1062 case MSVCRT__RC_DOWN
: fpword
|= 0x400; break;
1064 switch (flags
& MSVCRT__MCW_PC
)
1066 case MSVCRT__PC_64
: fpword
|= 0x300; break;
1067 case MSVCRT__PC_53
: fpword
|= 0x200; break;
1068 case MSVCRT__PC_24
: fpword
|= 0x0; break;
1070 if (flags
& MSVCRT__IC_AFFINE
) fpword
|= 0x1000;
1072 __asm__
__volatile__( "fldcw %0" : : "m" (fpword
) );
1077 if (!sse2_cw
) return 1;
1081 __asm__
__volatile__( "stmxcsr %0" : "=m" (fpword
) );
1083 /* Convert into mask constants */
1085 if (fpword
& 0x80) flags
|= MSVCRT__EM_INVALID
;
1086 if (fpword
& 0x100) flags
|= MSVCRT__EM_DENORMAL
;
1087 if (fpword
& 0x200) flags
|= MSVCRT__EM_ZERODIVIDE
;
1088 if (fpword
& 0x400) flags
|= MSVCRT__EM_OVERFLOW
;
1089 if (fpword
& 0x800) flags
|= MSVCRT__EM_UNDERFLOW
;
1090 if (fpword
& 0x1000) flags
|= MSVCRT__EM_INEXACT
;
1091 switch (fpword
& 0x6000)
1093 case 0x6000: flags
|= MSVCRT__RC_UP
|MSVCRT__RC_DOWN
; break;
1094 case 0x4000: flags
|= MSVCRT__RC_UP
; break;
1095 case 0x2000: flags
|= MSVCRT__RC_DOWN
; break;
1097 switch (fpword
& 0x8040)
1099 case 0x0040: flags
|= MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS
; break;
1100 case 0x8000: flags
|= MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS
; break;
1101 case 0x8040: flags
|= MSVCRT__DN_FLUSH
; break;
1104 TRACE( "sse2 flags=%08x newval=%08x mask=%08x\n", flags
, newval
, mask
);
1107 flags
= (flags
& ~mask
) | (newval
& mask
);
1109 /* Convert (masked) value back to fp word */
1111 if (flags
& MSVCRT__EM_INVALID
) fpword
|= 0x80;
1112 if (flags
& MSVCRT__EM_DENORMAL
) fpword
|= 0x100;
1113 if (flags
& MSVCRT__EM_ZERODIVIDE
) fpword
|= 0x200;
1114 if (flags
& MSVCRT__EM_OVERFLOW
) fpword
|= 0x400;
1115 if (flags
& MSVCRT__EM_UNDERFLOW
) fpword
|= 0x800;
1116 if (flags
& MSVCRT__EM_INEXACT
) fpword
|= 0x1000;
1117 switch (flags
& MSVCRT__MCW_RC
)
1119 case MSVCRT__RC_UP
|MSVCRT__RC_DOWN
: fpword
|= 0x6000; break;
1120 case MSVCRT__RC_UP
: fpword
|= 0x4000; break;
1121 case MSVCRT__RC_DOWN
: fpword
|= 0x2000; break;
1123 switch (flags
& MSVCRT__MCW_DN
)
1125 case MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS
: fpword
|= 0x0040; break;
1126 case MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS
: fpword
|= 0x8000; break;
1127 case MSVCRT__DN_FLUSH
: fpword
|= 0x8040; break;
1129 __asm__
__volatile__( "ldmxcsr %0" : : "m" (fpword
) );
1137 FIXME( "not implemented\n" );
1143 /*********************************************************************
1144 * _control87 (MSVCRT.@)
1146 unsigned int CDECL
_control87(unsigned int newval
, unsigned int mask
)
1148 #if defined(__i386__) || defined(__x86_64__)
1149 unsigned int x86_cw
, sse2_cw
;
1151 __control87_2( newval
, mask
, &x86_cw
, &sse2_cw
);
1153 if ((x86_cw
^ sse2_cw
) & (MSVCRT__MCW_EM
| MSVCRT__MCW_RC
)) x86_cw
|= MSVCRT__EM_AMBIGUOUS
;
1156 FIXME( "not implemented\n" );
1161 /*********************************************************************
1162 * _controlfp (MSVCRT.@)
1164 unsigned int CDECL
_controlfp(unsigned int newval
, unsigned int mask
)
1166 return _control87( newval
, mask
& ~MSVCRT__EM_DENORMAL
);
1169 /*********************************************************************
1170 * _set_controlfp (MSVCRT.@)
1172 void CDECL
_set_controlfp( unsigned int newval
, unsigned int mask
)
1174 _controlfp( newval
, mask
);
1177 /*********************************************************************
1178 * _controlfp_s (MSVCRT.@)
1180 int CDECL
_controlfp_s(unsigned int *cur
, unsigned int newval
, unsigned int mask
)
1182 static const unsigned int all_flags
= (MSVCRT__MCW_EM
| MSVCRT__MCW_IC
| MSVCRT__MCW_RC
|
1183 MSVCRT__MCW_PC
| MSVCRT__MCW_DN
);
1186 if (!MSVCRT_CHECK_PMT( !(newval
& mask
& ~all_flags
) ))
1188 if (cur
) *cur
= _controlfp( 0, 0 ); /* retrieve it anyway */
1189 return MSVCRT_EINVAL
;
1191 val
= _controlfp( newval
, mask
);
1192 if (cur
) *cur
= val
;
1196 /*********************************************************************
1197 * _copysign (MSVCRT.@)
1199 double CDECL
MSVCRT__copysign(double num
, double sign
)
1201 /* FIXME: Behaviour for Nan/Inf? */
1203 return num
< 0.0 ? num
: -num
;
1204 return num
< 0.0 ? -num
: num
;
1207 /*********************************************************************
1208 * _finite (MSVCRT.@)
1210 int CDECL
MSVCRT__finite(double num
)
1212 return (finite(num
)?1:0); /* See comment for _isnan() */
1215 /*********************************************************************
1216 * _fpreset (MSVCRT.@)
1218 void CDECL
_fpreset(void)
1220 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1221 const unsigned int x86_cw
= 0x27f;
1222 __asm__
__volatile__( "fninit; fldcw %0" : : "m" (x86_cw
) );
1225 const unsigned long sse2_cw
= 0x1f80;
1226 __asm__
__volatile__( "ldmxcsr %0" : : "m" (sse2_cw
) );
1229 FIXME( "not implemented\n" );
1233 /*********************************************************************
1236 INT CDECL
MSVCRT__isnan(double num
)
1238 /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
1239 * Do the same, as the result may be used in calculations
1241 return isnan(num
) ? 1 : 0;
1244 /*********************************************************************
1247 double CDECL
MSVCRT__j0(double num
)
1249 /* FIXME: errno handling */
1253 /*********************************************************************
1256 double CDECL
MSVCRT__j1(double num
)
1258 /* FIXME: errno handling */
1262 /*********************************************************************
1265 double CDECL
MSVCRT__jn(int n
, double num
)
1267 /* FIXME: errno handling */
1271 /*********************************************************************
1274 double CDECL
MSVCRT__y0(double num
)
1277 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1279 if (MSVCRT__fpclass(retval
) == MSVCRT__FPCLASS_NINF
)
1281 *MSVCRT__errno() = MSVCRT_EDOM
;
1287 /*********************************************************************
1290 double CDECL
MSVCRT__y1(double num
)
1293 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1295 if (MSVCRT__fpclass(retval
) == MSVCRT__FPCLASS_NINF
)
1297 *MSVCRT__errno() = MSVCRT_EDOM
;
1303 /*********************************************************************
1306 double CDECL
MSVCRT__yn(int order
, double num
)
1309 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1310 retval
= yn(order
,num
);
1311 if (MSVCRT__fpclass(retval
) == MSVCRT__FPCLASS_NINF
)
1313 *MSVCRT__errno() = MSVCRT_EDOM
;
1319 /*********************************************************************
1320 * _nextafter (MSVCRT.@)
1322 double CDECL
MSVCRT__nextafter(double num
, double next
)
1325 if (!finite(num
) || !finite(next
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1326 retval
= nextafter(num
,next
);
1330 /*********************************************************************
1333 char * CDECL
_ecvt( double number
, int ndigits
, int *decpt
, int *sign
)
1336 thread_data_t
*data
= msvcrt_get_thread_data();
1337 /* FIXME: check better for overflow (native supports over 300 chars) */
1338 ndigits
= min( ndigits
, 80 - 7); /* 7 : space for dec point, 1 for "e",
1339 * 4 for exponent and one for
1340 * terminating '\0' */
1341 if (!data
->efcvt_buffer
)
1342 data
->efcvt_buffer
= MSVCRT_malloc( 80 ); /* ought to be enough */
1349 /* handle cases with zero ndigits or less */
1351 if( prec
< 1) prec
= 2;
1352 len
= snprintf(data
->efcvt_buffer
, 80, "%.*le", prec
- 1, number
);
1353 /* take the decimal "point away */
1355 memmove( data
->efcvt_buffer
+ 1, data
->efcvt_buffer
+ 2, len
- 1 );
1356 /* take the exponential "e" out */
1357 data
->efcvt_buffer
[ prec
] = '\0';
1358 /* read the exponent */
1359 sscanf( data
->efcvt_buffer
+ prec
+ 1, "%d", decpt
);
1361 /* adjust for some border cases */
1362 if( data
->efcvt_buffer
[0] == '0')/* value is zero */
1364 /* handle cases with zero ndigits or less */
1366 if( data
->efcvt_buffer
[ 0] >= '5')
1368 data
->efcvt_buffer
[ 0] = '\0';
1370 TRACE("out=\"%s\"\n",data
->efcvt_buffer
);
1371 return data
->efcvt_buffer
;
1374 /*********************************************************************
1375 * _ecvt_s (MSVCRT.@)
1377 int CDECL
_ecvt_s( char *buffer
, MSVCRT_size_t length
, double number
, int ndigits
, int *decpt
, int *sign
)
1381 const char infret
[] = "1#INF";
1383 if (!MSVCRT_CHECK_PMT(buffer
!= NULL
)) return MSVCRT_EINVAL
;
1384 if (!MSVCRT_CHECK_PMT(decpt
!= NULL
)) return MSVCRT_EINVAL
;
1385 if (!MSVCRT_CHECK_PMT(sign
!= NULL
)) return MSVCRT_EINVAL
;
1386 if (!MSVCRT_CHECK_PMT_ERR( length
> 2, MSVCRT_ERANGE
)) return MSVCRT_ERANGE
;
1387 if (!MSVCRT_CHECK_PMT_ERR(ndigits
< (int)length
- 1, MSVCRT_ERANGE
)) return MSVCRT_ERANGE
;
1389 /* special case - inf */
1390 if(number
== HUGE_VAL
|| number
== -HUGE_VAL
)
1392 memset(buffer
, '0', ndigits
);
1393 memcpy(buffer
, infret
, min(ndigits
, sizeof(infret
) - 1 ) );
1394 buffer
[ndigits
] = '\0';
1396 if(number
== -HUGE_VAL
)
1402 /* handle cases with zero ndigits or less */
1404 if( prec
< 1) prec
= 2;
1405 result
= MSVCRT_malloc(prec
+ 7);
1412 len
= snprintf(result
, prec
+ 7, "%.*le", prec
- 1, number
);
1413 /* take the decimal "point away */
1415 memmove( result
+ 1, result
+ 2, len
- 1 );
1416 /* take the exponential "e" out */
1417 result
[ prec
] = '\0';
1418 /* read the exponent */
1419 sscanf( result
+ prec
+ 1, "%d", decpt
);
1421 /* adjust for some border cases */
1422 if( result
[0] == '0')/* value is zero */
1424 /* handle cases with zero ndigits or less */
1426 if( result
[ 0] >= '5')
1430 memcpy( buffer
, result
, max(ndigits
+ 1, 1) );
1431 MSVCRT_free( result
);
1435 /***********************************************************************
1438 char * CDECL
_fcvt( double number
, int ndigits
, int *decpt
, int *sign
)
1440 thread_data_t
*data
= msvcrt_get_thread_data();
1441 int stop
, dec1
, dec2
;
1442 char *ptr1
, *ptr2
, *first
;
1443 char buf
[80]; /* ought to be enough */
1445 if (!data
->efcvt_buffer
)
1446 data
->efcvt_buffer
= MSVCRT_malloc( 80 ); /* ought to be enough */
1454 snprintf(buf
, 80, "%.*f", ndigits
< 0 ? 0 : ndigits
, number
);
1456 ptr2
= data
->efcvt_buffer
;
1461 /* For numbers below the requested resolution, work out where
1462 the decimal point will be rather than finding it in the string */
1463 if (number
< 1.0 && number
> 0.0) {
1464 dec2
= log10(number
+ 1e-10);
1465 if (-dec2
<= ndigits
) dec2
= 0;
1468 /* If requested digits is zero or less, we will need to truncate
1469 * the returned string */
1471 stop
= strlen(buf
) + ndigits
;
1476 while (*ptr1
== '0') ptr1
++; /* Skip leading zeroes */
1477 while (*ptr1
!= '\0' && *ptr1
!= '.') {
1478 if (!first
) first
= ptr2
;
1479 if ((ptr1
- buf
) < stop
) {
1490 while (*ptr1
== '0') { /* Process leading zeroes */
1495 while (*ptr1
!= '\0') {
1496 if (!first
) first
= ptr2
;
1503 /* We never found a non-zero digit, then our number is either
1504 * smaller than the requested precision, or 0.0 */
1509 first
= data
->efcvt_buffer
;
1514 *decpt
= dec2
? dec2
: dec1
;
1518 /***********************************************************************
1519 * _fcvt_s (MSVCRT.@)
1521 int CDECL
_fcvt_s(char* outbuffer
, MSVCRT_size_t size
, double number
, int ndigits
, int *decpt
, int *sign
)
1523 int stop
, dec1
, dec2
;
1524 char *ptr1
, *ptr2
, *first
;
1525 char buf
[80]; /* ought to be enough */
1527 if (!outbuffer
|| !decpt
|| !sign
|| size
== 0)
1529 *MSVCRT__errno() = MSVCRT_EINVAL
;
1530 return MSVCRT_EINVAL
;
1539 snprintf(buf
, 80, "%.*f", ndigits
< 0 ? 0 : ndigits
, number
);
1546 /* For numbers below the requested resolution, work out where
1547 the decimal point will be rather than finding it in the string */
1548 if (number
< 1.0 && number
> 0.0) {
1549 dec2
= log10(number
+ 1e-10);
1550 if (-dec2
<= ndigits
) dec2
= 0;
1553 /* If requested digits is zero or less, we will need to truncate
1554 * the returned string */
1556 stop
= strlen(buf
) + ndigits
;
1561 while (*ptr1
== '0') ptr1
++; /* Skip leading zeroes */
1562 while (*ptr1
!= '\0' && *ptr1
!= '.') {
1563 if (!first
) first
= ptr2
;
1564 if ((ptr1
- buf
) < stop
) {
1578 while (*ptr1
== '0') { /* Process leading zeroes */
1579 if (number
== 0.0 && size
> 1) {
1587 while (*ptr1
!= '\0') {
1588 if (!first
) first
= ptr2
;
1598 /* We never found a non-zero digit, then our number is either
1599 * smaller than the requested precision, or 0.0 */
1600 if (!first
&& (number
<= 0.0))
1603 *decpt
= dec2
? dec2
: dec1
;
1607 /***********************************************************************
1610 char * CDECL
_gcvt( double number
, int ndigit
, char *buff
)
1613 *MSVCRT__errno() = MSVCRT_EINVAL
;
1618 *MSVCRT__errno() = MSVCRT_ERANGE
;
1622 MSVCRT_sprintf(buff
, "%.*g", ndigit
, number
);
1626 /***********************************************************************
1627 * _gcvt_s (MSVCRT.@)
1629 int CDECL
_gcvt_s(char *buff
, MSVCRT_size_t size
, double number
, int digits
)
1634 *MSVCRT__errno() = MSVCRT_EINVAL
;
1635 return MSVCRT_EINVAL
;
1638 if( digits
<0 || digits
>=size
) {
1642 *MSVCRT__errno() = MSVCRT_ERANGE
;
1643 return MSVCRT_ERANGE
;
1646 len
= MSVCRT__scprintf("%.*g", digits
, number
);
1649 *MSVCRT__errno() = MSVCRT_ERANGE
;
1650 return MSVCRT_ERANGE
;
1653 MSVCRT_sprintf(buff
, "%.*g", digits
, number
);
1657 #include <stdlib.h> /* div_t, ldiv_t */
1659 /*********************************************************************
1662 * [i386] Windows binary compatible - returns the struct in eax/edx.
1665 unsigned __int64 CDECL
MSVCRT_div(int num
, int denom
)
1667 div_t dt
= div(num
,denom
);
1668 return ((unsigned __int64
)dt
.rem
<< 32) | (unsigned int)dt
.quot
;
1671 /*********************************************************************
1674 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1676 MSVCRT_div_t CDECL
MSVCRT_div(int num
, int denom
)
1678 div_t dt
= div(num
,denom
);
1686 #endif /* ifdef __i386__ */
1689 /*********************************************************************
1692 * [i386] Windows binary compatible - returns the struct in eax/edx.
1695 unsigned __int64 CDECL
MSVCRT_ldiv(MSVCRT_long num
, MSVCRT_long denom
)
1697 ldiv_t ldt
= ldiv(num
,denom
);
1698 return ((unsigned __int64
)ldt
.rem
<< 32) | (MSVCRT_ulong
)ldt
.quot
;
1701 /*********************************************************************
1704 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1706 MSVCRT_ldiv_t CDECL
MSVCRT_ldiv(MSVCRT_long num
, MSVCRT_long denom
)
1708 ldiv_t result
= ldiv(num
,denom
);
1711 ret
.quot
= result
.quot
;
1712 ret
.rem
= result
.rem
;
1716 #endif /* ifdef __i386__ */
1720 /*********************************************************************
1721 * _adjust_fdiv (MSVCRT.@)
1722 * Used by the MSVC compiler to work around the Pentium FDIV bug.
1724 int MSVCRT__adjust_fdiv
= 0;
1726 /***********************************************************************
1727 * _adj_fdiv_m16i (MSVCRT.@)
1730 * I _think_ this function is intended to work around the Pentium
1733 void __stdcall
_adj_fdiv_m16i( short arg
)
1735 TRACE("(): stub\n");
1738 /***********************************************************************
1739 * _adj_fdiv_m32 (MSVCRT.@)
1742 * I _think_ this function is intended to work around the Pentium
1745 void __stdcall
_adj_fdiv_m32( unsigned int arg
)
1747 TRACE("(): stub\n");
1750 /***********************************************************************
1751 * _adj_fdiv_m32i (MSVCRT.@)
1754 * I _think_ this function is intended to work around the Pentium
1757 void __stdcall
_adj_fdiv_m32i( int arg
)
1759 TRACE("(): stub\n");
1762 /***********************************************************************
1763 * _adj_fdiv_m64 (MSVCRT.@)
1766 * I _think_ this function is intended to work around the Pentium
1769 void __stdcall
_adj_fdiv_m64( unsigned __int64 arg
)
1771 TRACE("(): stub\n");
1774 /***********************************************************************
1775 * _adj_fdiv_r (MSVCRT.@)
1777 * This function is likely to have the wrong number of arguments.
1780 * I _think_ this function is intended to work around the Pentium
1783 void _adj_fdiv_r(void)
1785 TRACE("(): stub\n");
1788 /***********************************************************************
1789 * _adj_fdivr_m16i (MSVCRT.@)
1792 * I _think_ this function is intended to work around the Pentium
1795 void __stdcall
_adj_fdivr_m16i( short arg
)
1797 TRACE("(): stub\n");
1800 /***********************************************************************
1801 * _adj_fdivr_m32 (MSVCRT.@)
1804 * I _think_ this function is intended to work around the Pentium
1807 void __stdcall
_adj_fdivr_m32( unsigned int arg
)
1809 TRACE("(): stub\n");
1812 /***********************************************************************
1813 * _adj_fdivr_m32i (MSVCRT.@)
1816 * I _think_ this function is intended to work around the Pentium
1819 void __stdcall
_adj_fdivr_m32i( int arg
)
1821 TRACE("(): stub\n");
1824 /***********************************************************************
1825 * _adj_fdivr_m64 (MSVCRT.@)
1828 * I _think_ this function is intended to work around the Pentium
1831 void __stdcall
_adj_fdivr_m64( unsigned __int64 arg
)
1833 TRACE("(): stub\n");
1836 /***********************************************************************
1837 * _adj_fpatan (MSVCRT.@)
1839 * This function is likely to have the wrong number of arguments.
1842 * I _think_ this function is intended to work around the Pentium
1845 void _adj_fpatan(void)
1847 TRACE("(): stub\n");
1850 /***********************************************************************
1851 * _adj_fprem (MSVCRT.@)
1853 * This function is likely to have the wrong number of arguments.
1856 * I _think_ this function is intended to work around the Pentium
1859 void _adj_fprem(void)
1861 TRACE("(): stub\n");
1864 /***********************************************************************
1865 * _adj_fprem1 (MSVCRT.@)
1867 * This function is likely to have the wrong number of arguments.
1870 * I _think_ this function is intended to work around the Pentium
1873 void _adj_fprem1(void)
1875 TRACE("(): stub\n");
1878 /***********************************************************************
1879 * _adj_fptan (MSVCRT.@)
1881 * This function is likely to have the wrong number of arguments.
1884 * I _think_ this function is intended to work around the Pentium
1887 void _adj_fptan(void)
1889 TRACE("(): stub\n");
1892 /***********************************************************************
1893 * _safe_fdiv (MSVCRT.@)
1895 * This function is likely to have the wrong number of arguments.
1898 * I _think_ this function is intended to work around the Pentium
1901 void _safe_fdiv(void)
1903 TRACE("(): stub\n");
1906 /***********************************************************************
1907 * _safe_fdivr (MSVCRT.@)
1909 * This function is likely to have the wrong number of arguments.
1912 * I _think_ this function is intended to work around the Pentium
1915 void _safe_fdivr(void)
1917 TRACE("(): stub\n");
1920 /***********************************************************************
1921 * _safe_fprem (MSVCRT.@)
1923 * This function is likely to have the wrong number of arguments.
1926 * I _think_ this function is intended to work around the Pentium
1929 void _safe_fprem(void)
1931 TRACE("(): stub\n");
1934 /***********************************************************************
1935 * _safe_fprem1 (MSVCRT.@)
1938 * This function is likely to have the wrong number of arguments.
1941 * I _think_ this function is intended to work around the Pentium
1944 void _safe_fprem1(void)
1946 TRACE("(): stub\n");
1949 /***********************************************************************
1950 * __libm_sse2_acos (MSVCRT.@)
1952 void __cdecl
__libm_sse2_acos(void)
1955 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
1957 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
1960 /***********************************************************************
1961 * __libm_sse2_acosf (MSVCRT.@)
1963 void __cdecl
__libm_sse2_acosf(void)
1966 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
1968 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
1971 /***********************************************************************
1972 * __libm_sse2_asin (MSVCRT.@)
1974 void __cdecl
__libm_sse2_asin(void)
1977 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
1979 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
1982 /***********************************************************************
1983 * __libm_sse2_asinf (MSVCRT.@)
1985 void __cdecl
__libm_sse2_asinf(void)
1988 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
1990 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
1993 /***********************************************************************
1994 * __libm_sse2_atan (MSVCRT.@)
1996 void __cdecl
__libm_sse2_atan(void)
1999 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2001 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2004 /***********************************************************************
2005 * __libm_sse2_atan2 (MSVCRT.@)
2007 void __cdecl
__libm_sse2_atan2(void)
2010 __asm__
__volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1
), "=m" (d2
) );
2011 d1
= atan2( d1
, d2
);
2012 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d1
) );
2015 /***********************************************************************
2016 * __libm_sse2_atanf (MSVCRT.@)
2018 void __cdecl
__libm_sse2_atanf(void)
2021 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2023 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2026 /***********************************************************************
2027 * __libm_sse2_cos (MSVCRT.@)
2029 void __cdecl
__libm_sse2_cos(void)
2032 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2034 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2037 /***********************************************************************
2038 * __libm_sse2_cosf (MSVCRT.@)
2040 void __cdecl
__libm_sse2_cosf(void)
2043 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2045 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2048 /***********************************************************************
2049 * __libm_sse2_exp (MSVCRT.@)
2051 void __cdecl
__libm_sse2_exp(void)
2054 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2056 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2059 /***********************************************************************
2060 * __libm_sse2_expf (MSVCRT.@)
2062 void __cdecl
__libm_sse2_expf(void)
2065 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2067 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2070 /***********************************************************************
2071 * __libm_sse2_log (MSVCRT.@)
2073 void __cdecl
__libm_sse2_log(void)
2076 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2078 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2081 /***********************************************************************
2082 * __libm_sse2_log10 (MSVCRT.@)
2084 void __cdecl
__libm_sse2_log10(void)
2087 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2089 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2092 /***********************************************************************
2093 * __libm_sse2_log10f (MSVCRT.@)
2095 void __cdecl
__libm_sse2_log10f(void)
2098 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2100 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2103 /***********************************************************************
2104 * __libm_sse2_logf (MSVCRT.@)
2106 void __cdecl
__libm_sse2_logf(void)
2109 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2111 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2114 /***********************************************************************
2115 * __libm_sse2_pow (MSVCRT.@)
2117 void __cdecl
__libm_sse2_pow(void)
2120 __asm__
__volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1
), "=m" (d2
) );
2122 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d1
) );
2125 /***********************************************************************
2126 * __libm_sse2_powf (MSVCRT.@)
2128 void __cdecl
__libm_sse2_powf(void)
2131 __asm__
__volatile__( "movd %%xmm0,%0; movd %%xmm1,%1" : "=g" (f1
), "=g" (f2
) );
2132 f1
= powf( f1
, f2
);
2133 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f1
) );
2136 /***********************************************************************
2137 * __libm_sse2_sin (MSVCRT.@)
2139 void __cdecl
__libm_sse2_sin(void)
2142 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2144 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2147 /***********************************************************************
2148 * __libm_sse2_sinf (MSVCRT.@)
2150 void __cdecl
__libm_sse2_sinf(void)
2153 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2155 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2158 /***********************************************************************
2159 * __libm_sse2_tan (MSVCRT.@)
2161 void __cdecl
__libm_sse2_tan(void)
2164 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2166 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2169 /***********************************************************************
2170 * __libm_sse2_tanf (MSVCRT.@)
2172 void __cdecl
__libm_sse2_tanf(void)
2175 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2177 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2180 #endif /* __i386__ */