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 * MSVCRT_acosf (MSVCRT.@)
76 float CDECL
MSVCRT_acosf( float x
)
78 if (x
< -1.0 || x
> 1.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
79 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
80 * asin() uses a similar construction. This is bad because as x gets nearer to
81 * 1 the error in the expression "1 - x^2" can get relatively large due to
82 * cancellation. The sqrt() makes things worse. A safer way to calculate
83 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
84 return atan2f(sqrtf((1 - x
) * (1 + x
)), x
);
87 /*********************************************************************
88 * MSVCRT_asinf (MSVCRT.@)
90 float CDECL
MSVCRT_asinf( float x
)
92 if (x
< -1.0 || x
> 1.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
93 return atan2f(x
, sqrtf((1 - x
) * (1 + x
)));
96 /*********************************************************************
97 * MSVCRT_atanf (MSVCRT.@)
99 float CDECL
MSVCRT_atanf( float x
)
101 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
105 /*********************************************************************
106 * MSVCRT_atan2f (MSVCRT.@)
108 float CDECL
MSVCRT_atan2f( float x
, float y
)
110 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
114 /*********************************************************************
115 * MSVCRT_cosf (MSVCRT.@)
117 float CDECL
MSVCRT_cosf( float x
)
119 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
123 /*********************************************************************
124 * MSVCRT_coshf (MSVCRT.@)
126 float CDECL
MSVCRT_coshf( float x
)
128 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
132 /*********************************************************************
133 * MSVCRT_expf (MSVCRT.@)
135 float CDECL
MSVCRT_expf( float x
)
137 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
141 /*********************************************************************
142 * MSVCRT_fmodf (MSVCRT.@)
144 float CDECL
MSVCRT_fmodf( float x
, float y
)
146 if (!finitef(x
) || !finitef(y
)) *MSVCRT__errno() = MSVCRT_EDOM
;
150 /*********************************************************************
151 * MSVCRT_logf (MSVCRT.@)
153 float CDECL
MSVCRT_logf( float x
)
155 if (x
< 0.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
156 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
160 /*********************************************************************
161 * MSVCRT_log10f (MSVCRT.@)
163 float CDECL
MSVCRT_log10f( float x
)
165 if (x
< 0.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
166 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
170 /*********************************************************************
171 * MSVCRT_powf (MSVCRT.@)
173 float CDECL
MSVCRT_powf( float x
, float y
)
175 /* FIXME: If x < 0 and y is not integral, set EDOM */
177 if (!finitef(z
)) *MSVCRT__errno() = MSVCRT_EDOM
;
181 /*********************************************************************
182 * MSVCRT_sinf (MSVCRT.@)
184 float CDECL
MSVCRT_sinf( float x
)
186 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
190 /*********************************************************************
191 * MSVCRT_sinhf (MSVCRT.@)
193 float CDECL
MSVCRT_sinhf( float x
)
195 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
199 /*********************************************************************
200 * MSVCRT_sqrtf (MSVCRT.@)
202 float CDECL
MSVCRT_sqrtf( float x
)
204 if (x
< 0.0 || !finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
208 /*********************************************************************
209 * MSVCRT_tanf (MSVCRT.@)
211 float CDECL
MSVCRT_tanf( float x
)
213 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
217 /*********************************************************************
218 * MSVCRT_tanhf (MSVCRT.@)
220 float CDECL
MSVCRT_tanhf( float x
)
222 if (!finitef(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
226 /*********************************************************************
229 float CDECL
MSVCRT_ceilf( float x
)
234 /*********************************************************************
237 float CDECL
MSVCRT_floorf( float x
)
242 /*********************************************************************
245 float CDECL
MSVCRT_frexpf( float x
, int *exp
)
247 return frexpf( x
, exp
);
250 /*********************************************************************
253 float CDECL
MSVCRT__scalbf(float num
, MSVCRT_long power
)
255 if (!finitef(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
256 return ldexpf(num
, power
);
259 /*********************************************************************
262 double CDECL
MSVCRT_modff( float x
, float *iptr
)
264 return modff( x
, iptr
);
269 /*********************************************************************
270 * MSVCRT_acos (MSVCRT.@)
272 double CDECL
MSVCRT_acos( double x
)
274 if (x
< -1.0 || x
> 1.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
275 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
276 * asin() uses a similar construction. This is bad because as x gets nearer to
277 * 1 the error in the expression "1 - x^2" can get relatively large due to
278 * cancellation. The sqrt() makes things worse. A safer way to calculate
279 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
280 return atan2(sqrt((1 - x
) * (1 + x
)), x
);
283 /*********************************************************************
284 * MSVCRT_asin (MSVCRT.@)
286 double CDECL
MSVCRT_asin( double x
)
288 if (x
< -1.0 || x
> 1.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
289 return atan2(x
, sqrt((1 - x
) * (1 + x
)));
292 /*********************************************************************
293 * MSVCRT_atan (MSVCRT.@)
295 double CDECL
MSVCRT_atan( double x
)
297 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
301 /*********************************************************************
302 * MSVCRT_atan2 (MSVCRT.@)
304 double CDECL
MSVCRT_atan2( double x
, double y
)
306 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
310 /*********************************************************************
311 * MSVCRT_cos (MSVCRT.@)
313 double CDECL
MSVCRT_cos( double x
)
315 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
319 /*********************************************************************
320 * MSVCRT_cosh (MSVCRT.@)
322 double CDECL
MSVCRT_cosh( double x
)
324 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
328 /*********************************************************************
329 * MSVCRT_exp (MSVCRT.@)
331 double CDECL
MSVCRT_exp( double x
)
333 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
337 /*********************************************************************
338 * MSVCRT_fmod (MSVCRT.@)
340 double CDECL
MSVCRT_fmod( double x
, double y
)
342 if (!finite(x
) || !finite(y
)) *MSVCRT__errno() = MSVCRT_EDOM
;
346 /*********************************************************************
347 * MSVCRT_log (MSVCRT.@)
349 double CDECL
MSVCRT_log( double x
)
351 if (x
< 0.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
352 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
356 /*********************************************************************
357 * MSVCRT_log10 (MSVCRT.@)
359 double CDECL
MSVCRT_log10( double x
)
361 if (x
< 0.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
362 if (x
== 0.0) *MSVCRT__errno() = MSVCRT_ERANGE
;
366 /*********************************************************************
367 * MSVCRT_pow (MSVCRT.@)
369 double CDECL
MSVCRT_pow( double x
, double y
)
371 /* FIXME: If x < 0 and y is not integral, set EDOM */
373 if (!finite(z
)) *MSVCRT__errno() = MSVCRT_EDOM
;
377 /*********************************************************************
378 * MSVCRT_sin (MSVCRT.@)
380 double CDECL
MSVCRT_sin( double x
)
382 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
386 /*********************************************************************
387 * MSVCRT_sinh (MSVCRT.@)
389 double CDECL
MSVCRT_sinh( double x
)
391 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
395 /*********************************************************************
396 * MSVCRT_sqrt (MSVCRT.@)
398 double CDECL
MSVCRT_sqrt( double x
)
400 if (x
< 0.0 || !finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
404 /*********************************************************************
405 * MSVCRT_tan (MSVCRT.@)
407 double CDECL
MSVCRT_tan( double x
)
409 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
413 /*********************************************************************
414 * MSVCRT_tanh (MSVCRT.@)
416 double CDECL
MSVCRT_tanh( double x
)
418 if (!finite(x
)) *MSVCRT__errno() = MSVCRT_EDOM
;
423 #if defined(__GNUC__) && defined(__i386__)
425 #define FPU_DOUBLE(var) double var; \
426 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
427 #define FPU_DOUBLES(var1,var2) double var1,var2; \
428 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
429 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
431 /*********************************************************************
434 double CDECL
_CIacos(void)
437 return MSVCRT_acos(x
);
440 /*********************************************************************
443 double CDECL
_CIasin(void)
446 return MSVCRT_asin(x
);
449 /*********************************************************************
452 double CDECL
_CIatan(void)
455 return MSVCRT_atan(x
);
458 /*********************************************************************
459 * _CIatan2 (MSVCRT.@)
461 double CDECL
_CIatan2(void)
464 return MSVCRT_atan2(x
,y
);
467 /*********************************************************************
470 double CDECL
_CIcos(void)
473 return MSVCRT_cos(x
);
476 /*********************************************************************
479 double CDECL
_CIcosh(void)
482 return MSVCRT_cosh(x
);
485 /*********************************************************************
488 double CDECL
_CIexp(void)
491 return MSVCRT_exp(x
);
494 /*********************************************************************
497 double CDECL
_CIfmod(void)
500 return MSVCRT_fmod(x
,y
);
503 /*********************************************************************
506 double CDECL
_CIlog(void)
509 return MSVCRT_log(x
);
512 /*********************************************************************
513 * _CIlog10 (MSVCRT.@)
515 double CDECL
_CIlog10(void)
518 return MSVCRT_log10(x
);
521 /*********************************************************************
524 double CDECL
_CIpow(void)
527 return MSVCRT_pow(x
,y
);
530 /*********************************************************************
533 double CDECL
_CIsin(void)
536 return MSVCRT_sin(x
);
539 /*********************************************************************
542 double CDECL
_CIsinh(void)
545 return MSVCRT_sinh(x
);
548 /*********************************************************************
551 double CDECL
_CIsqrt(void)
554 return MSVCRT_sqrt(x
);
557 /*********************************************************************
560 double CDECL
_CItan(void)
563 return MSVCRT_tan(x
);
566 /*********************************************************************
569 double CDECL
_CItanh(void)
572 return MSVCRT_tanh(x
);
575 #endif /* defined(__GNUC__) && defined(__i386__) */
577 /*********************************************************************
578 * _fpclass (MSVCRT.@)
580 int CDECL
MSVCRT__fpclass(double num
)
582 #if defined(HAVE_FPCLASS) || defined(fpclass)
583 switch (fpclass( num
))
586 case FP_SNAN
: return MSVCRT__FPCLASS_SNAN
;
589 case FP_QNAN
: return MSVCRT__FPCLASS_QNAN
;
592 case FP_NINF
: return MSVCRT__FPCLASS_NINF
;
595 case FP_PINF
: return MSVCRT__FPCLASS_PINF
;
598 case FP_NDENORM
: return MSVCRT__FPCLASS_ND
;
601 case FP_PDENORM
: return MSVCRT__FPCLASS_PD
;
604 case FP_NZERO
: return MSVCRT__FPCLASS_NZ
;
607 case FP_PZERO
: return MSVCRT__FPCLASS_PZ
;
610 case FP_NNORM
: return MSVCRT__FPCLASS_NN
;
613 case FP_PNORM
: return MSVCRT__FPCLASS_PN
;
615 default: return MSVCRT__FPCLASS_PN
;
617 #elif defined (fpclassify)
618 switch (fpclassify( num
))
620 case FP_NAN
: return MSVCRT__FPCLASS_QNAN
;
621 case FP_INFINITE
: return signbit(num
) ? MSVCRT__FPCLASS_NINF
: MSVCRT__FPCLASS_PINF
;
622 case FP_SUBNORMAL
: return signbit(num
) ?MSVCRT__FPCLASS_ND
: MSVCRT__FPCLASS_PD
;
623 case FP_ZERO
: return signbit(num
) ? MSVCRT__FPCLASS_NZ
: MSVCRT__FPCLASS_PZ
;
625 return signbit(num
) ? MSVCRT__FPCLASS_NN
: MSVCRT__FPCLASS_PN
;
628 return MSVCRT__FPCLASS_QNAN
;
629 return num
== 0.0 ? MSVCRT__FPCLASS_PZ
: (num
< 0 ? MSVCRT__FPCLASS_NN
: MSVCRT__FPCLASS_PN
);
633 /*********************************************************************
636 unsigned int CDECL
_rotl(unsigned int num
, int shift
)
639 return (num
<< shift
) | (num
>> (32-shift
));
642 /*********************************************************************
645 MSVCRT_ulong CDECL
MSVCRT__lrotl(MSVCRT_ulong num
, int shift
)
648 return (num
<< shift
) | (num
>> (32-shift
));
651 /*********************************************************************
654 MSVCRT_ulong CDECL
MSVCRT__lrotr(MSVCRT_ulong num
, int shift
)
657 return (num
>> shift
) | (num
<< (32-shift
));
660 /*********************************************************************
663 unsigned int CDECL
_rotr(unsigned int num
, int shift
)
666 return (num
>> shift
) | (num
<< (32-shift
));
669 /*********************************************************************
672 unsigned __int64 CDECL
_rotl64(unsigned __int64 num
, int shift
)
675 return (num
<< shift
) | (num
>> (64-shift
));
678 /*********************************************************************
681 unsigned __int64 CDECL
_rotr64(unsigned __int64 num
, int shift
)
684 return (num
>> shift
) | (num
<< (64-shift
));
687 /*********************************************************************
690 int CDECL
MSVCRT_abs( int n
)
692 return n
>= 0 ? n
: -n
;
695 /*********************************************************************
698 MSVCRT_long CDECL
MSVCRT_labs( MSVCRT_long n
)
700 return n
>= 0 ? n
: -n
;
703 /*********************************************************************
706 __int64 CDECL
_abs64( __int64 n
)
708 return n
>= 0 ? n
: -n
;
711 /*********************************************************************
714 double CDECL
MSVCRT__logb(double num
)
716 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
720 /*********************************************************************
723 double CDECL
MSVCRT__scalb(double num
, MSVCRT_long power
)
725 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
726 return ldexp(num
, power
);
729 /*********************************************************************
732 double CDECL
_hypot(double x
, double y
)
734 /* FIXME: errno handling */
735 return hypot( x
, y
);
738 /*********************************************************************
741 float CDECL
MSVCRT__hypotf(float x
, float y
)
743 /* FIXME: errno handling */
744 return hypotf( x
, y
);
747 /*********************************************************************
750 double CDECL
MSVCRT_ceil( double x
)
755 /*********************************************************************
758 double CDECL
MSVCRT_floor( double x
)
763 /*********************************************************************
766 double CDECL
MSVCRT_fabs( double x
)
771 /*********************************************************************
774 double CDECL
MSVCRT_frexp( double x
, int *exp
)
776 return frexp( x
, exp
);
779 /*********************************************************************
782 double CDECL
MSVCRT_modf( double x
, double *iptr
)
784 return modf( x
, iptr
);
787 /*********************************************************************
788 * _matherr (MSVCRT.@)
790 int CDECL
MSVCRT__matherr(struct MSVCRT__exception
*e
)
793 TRACE("(%p = %d, %s, %g %g %g)\n",e
, e
->type
, e
->name
, e
->arg1
, e
->arg2
,
797 if (MSVCRT_default_matherr_func
)
798 return MSVCRT_default_matherr_func(e
);
799 ERR(":Unhandled math error!\n");
803 /*********************************************************************
804 * __setusermatherr (MSVCRT.@)
806 void CDECL
MSVCRT___setusermatherr(MSVCRT_matherr_func func
)
808 MSVCRT_default_matherr_func
= func
;
809 TRACE(":new matherr handler %p\n", func
);
812 /**********************************************************************
813 * _statusfp2 (MSVCRT.@)
815 * Not exported by native msvcrt, added in msvcr80.
817 #if defined(__i386__) || defined(__x86_64__)
818 void CDECL
_statusfp2( unsigned int *x86_sw
, unsigned int *sse2_sw
)
822 unsigned long fpword
;
826 __asm__
__volatile__( "fstsw %0" : "=m" (fpword
) );
828 if (fpword
& 0x1) flags
|= MSVCRT__SW_INVALID
;
829 if (fpword
& 0x2) flags
|= MSVCRT__SW_DENORMAL
;
830 if (fpword
& 0x4) flags
|= MSVCRT__SW_ZERODIVIDE
;
831 if (fpword
& 0x8) flags
|= MSVCRT__SW_OVERFLOW
;
832 if (fpword
& 0x10) flags
|= MSVCRT__SW_UNDERFLOW
;
833 if (fpword
& 0x20) flags
|= MSVCRT__SW_INEXACT
;
837 if (!sse2_sw
) return;
841 __asm__
__volatile__( "stmxcsr %0" : "=m" (fpword
) );
843 if (fpword
& 0x1) flags
|= MSVCRT__SW_INVALID
;
844 if (fpword
& 0x2) flags
|= MSVCRT__SW_DENORMAL
;
845 if (fpword
& 0x4) flags
|= MSVCRT__SW_ZERODIVIDE
;
846 if (fpword
& 0x8) flags
|= MSVCRT__SW_OVERFLOW
;
847 if (fpword
& 0x10) flags
|= MSVCRT__SW_UNDERFLOW
;
848 if (fpword
& 0x20) flags
|= MSVCRT__SW_INEXACT
;
853 FIXME( "not implemented\n" );
858 /**********************************************************************
859 * _statusfp (MSVCRT.@)
861 unsigned int CDECL
_statusfp(void)
863 #if defined(__i386__) || defined(__x86_64__)
864 unsigned int x86_sw
, sse2_sw
;
866 _statusfp2( &x86_sw
, &sse2_sw
);
867 /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
868 return x86_sw
| sse2_sw
;
870 FIXME( "not implemented\n" );
875 /*********************************************************************
876 * _clearfp (MSVCRT.@)
878 unsigned int CDECL
_clearfp(void)
880 unsigned int flags
= 0;
881 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
882 unsigned long fpword
;
884 __asm__
__volatile__( "fnstsw %0; fnclex" : "=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 __asm__
__volatile__( "stmxcsr %0" : "=m" (fpword
) );
895 if (fpword
& 0x1) flags
|= MSVCRT__SW_INVALID
;
896 if (fpword
& 0x2) flags
|= MSVCRT__SW_DENORMAL
;
897 if (fpword
& 0x4) flags
|= MSVCRT__SW_ZERODIVIDE
;
898 if (fpword
& 0x8) flags
|= MSVCRT__SW_OVERFLOW
;
899 if (fpword
& 0x10) flags
|= MSVCRT__SW_UNDERFLOW
;
900 if (fpword
& 0x20) flags
|= MSVCRT__SW_INEXACT
;
902 __asm__
__volatile__( "ldmxcsr %0" : : "m" (fpword
) );
905 FIXME( "not implemented\n" );
910 /*********************************************************************
911 * __fpecode (MSVCRT.@)
913 int * CDECL
__fpecode(void)
915 return &msvcrt_get_thread_data()->fpecode
;
918 /*********************************************************************
921 double CDECL
MSVCRT_ldexp(double num
, MSVCRT_long exp
)
923 double z
= ldexp(num
,exp
);
926 *MSVCRT__errno() = MSVCRT_ERANGE
;
927 else if (z
== 0 && signbit(z
))
928 z
= 0.0; /* Convert -0 -> +0 */
932 /*********************************************************************
935 double CDECL
MSVCRT__cabs(struct MSVCRT__complex num
)
937 return sqrt(num
.x
* num
.x
+ num
.y
* num
.y
);
940 /*********************************************************************
941 * _chgsign (MSVCRT.@)
943 double CDECL
MSVCRT__chgsign(double num
)
945 /* FIXME: +-infinity,Nan not tested */
949 /*********************************************************************
950 * __control87_2 (MSVCRT.@)
952 * Not exported by native msvcrt, added in msvcr80.
954 #if defined(__i386__) || defined(__x86_64__)
955 int CDECL
__control87_2( unsigned int newval
, unsigned int mask
,
956 unsigned int *x86_cw
, unsigned int *sse2_cw
)
959 unsigned long fpword
;
964 __asm__
__volatile__( "fstcw %0" : "=m" (fpword
) );
966 /* Convert into mask constants */
968 if (fpword
& 0x1) flags
|= MSVCRT__EM_INVALID
;
969 if (fpword
& 0x2) flags
|= MSVCRT__EM_DENORMAL
;
970 if (fpword
& 0x4) flags
|= MSVCRT__EM_ZERODIVIDE
;
971 if (fpword
& 0x8) flags
|= MSVCRT__EM_OVERFLOW
;
972 if (fpword
& 0x10) flags
|= MSVCRT__EM_UNDERFLOW
;
973 if (fpword
& 0x20) flags
|= MSVCRT__EM_INEXACT
;
974 switch (fpword
& 0xc00)
976 case 0xc00: flags
|= MSVCRT__RC_UP
|MSVCRT__RC_DOWN
; break;
977 case 0x800: flags
|= MSVCRT__RC_UP
; break;
978 case 0x400: flags
|= MSVCRT__RC_DOWN
; break;
980 switch (fpword
& 0x300)
982 case 0x0: flags
|= MSVCRT__PC_24
; break;
983 case 0x200: flags
|= MSVCRT__PC_53
; break;
984 case 0x300: flags
|= MSVCRT__PC_64
; break;
986 if (fpword
& 0x1000) flags
|= MSVCRT__IC_AFFINE
;
988 TRACE( "x86 flags=%08x newval=%08x mask=%08x\n", flags
, newval
, mask
);
991 flags
= (flags
& ~mask
) | (newval
& mask
);
993 /* Convert (masked) value back to fp word */
995 if (flags
& MSVCRT__EM_INVALID
) fpword
|= 0x1;
996 if (flags
& MSVCRT__EM_DENORMAL
) fpword
|= 0x2;
997 if (flags
& MSVCRT__EM_ZERODIVIDE
) fpword
|= 0x4;
998 if (flags
& MSVCRT__EM_OVERFLOW
) fpword
|= 0x8;
999 if (flags
& MSVCRT__EM_UNDERFLOW
) fpword
|= 0x10;
1000 if (flags
& MSVCRT__EM_INEXACT
) fpword
|= 0x20;
1001 switch (flags
& MSVCRT__MCW_RC
)
1003 case MSVCRT__RC_UP
|MSVCRT__RC_DOWN
: fpword
|= 0xc00; break;
1004 case MSVCRT__RC_UP
: fpword
|= 0x800; break;
1005 case MSVCRT__RC_DOWN
: fpword
|= 0x400; break;
1007 switch (flags
& MSVCRT__MCW_PC
)
1009 case MSVCRT__PC_64
: fpword
|= 0x300; break;
1010 case MSVCRT__PC_53
: fpword
|= 0x200; break;
1011 case MSVCRT__PC_24
: fpword
|= 0x0; break;
1013 if (flags
& MSVCRT__IC_AFFINE
) fpword
|= 0x1000;
1015 __asm__
__volatile__( "fldcw %0" : : "m" (fpword
) );
1020 if (!sse2_cw
) return 1;
1024 __asm__
__volatile__( "stmxcsr %0" : "=m" (fpword
) );
1026 /* Convert into mask constants */
1028 if (fpword
& 0x80) flags
|= MSVCRT__EM_INVALID
;
1029 if (fpword
& 0x100) flags
|= MSVCRT__EM_DENORMAL
;
1030 if (fpword
& 0x200) flags
|= MSVCRT__EM_ZERODIVIDE
;
1031 if (fpword
& 0x400) flags
|= MSVCRT__EM_OVERFLOW
;
1032 if (fpword
& 0x800) flags
|= MSVCRT__EM_UNDERFLOW
;
1033 if (fpword
& 0x1000) flags
|= MSVCRT__EM_INEXACT
;
1034 switch (fpword
& 0x6000)
1036 case 0x6000: flags
|= MSVCRT__RC_UP
|MSVCRT__RC_DOWN
; break;
1037 case 0x4000: flags
|= MSVCRT__RC_UP
; break;
1038 case 0x2000: flags
|= MSVCRT__RC_DOWN
; break;
1040 switch (fpword
& 0x8040)
1042 case 0x0040: flags
|= MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS
; break;
1043 case 0x8000: flags
|= MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS
; break;
1044 case 0x8040: flags
|= MSVCRT__DN_FLUSH
; break;
1047 TRACE( "sse2 flags=%08x newval=%08x mask=%08x\n", flags
, newval
, mask
);
1050 flags
= (flags
& ~mask
) | (newval
& mask
);
1052 /* Convert (masked) value back to fp word */
1054 if (flags
& MSVCRT__EM_INVALID
) fpword
|= 0x80;
1055 if (flags
& MSVCRT__EM_DENORMAL
) fpword
|= 0x100;
1056 if (flags
& MSVCRT__EM_ZERODIVIDE
) fpword
|= 0x200;
1057 if (flags
& MSVCRT__EM_OVERFLOW
) fpword
|= 0x400;
1058 if (flags
& MSVCRT__EM_UNDERFLOW
) fpword
|= 0x800;
1059 if (flags
& MSVCRT__EM_INEXACT
) fpword
|= 0x1000;
1060 switch (flags
& MSVCRT__MCW_RC
)
1062 case MSVCRT__RC_UP
|MSVCRT__RC_DOWN
: fpword
|= 0x6000; break;
1063 case MSVCRT__RC_UP
: fpword
|= 0x4000; break;
1064 case MSVCRT__RC_DOWN
: fpword
|= 0x2000; break;
1066 switch (flags
& MSVCRT__MCW_DN
)
1068 case MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS
: fpword
|= 0x0040; break;
1069 case MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS
: fpword
|= 0x8000; break;
1070 case MSVCRT__DN_FLUSH
: fpword
|= 0x8040; break;
1072 __asm__
__volatile__( "ldmxcsr %0" : : "m" (fpword
) );
1080 FIXME( "not implemented\n" );
1086 /*********************************************************************
1087 * _control87 (MSVCRT.@)
1089 unsigned int CDECL
_control87(unsigned int newval
, unsigned int mask
)
1091 #if defined(__i386__) || defined(__x86_64__)
1092 unsigned int x86_cw
, sse2_cw
;
1094 __control87_2( newval
, mask
, &x86_cw
, &sse2_cw
);
1096 if ((x86_cw
^ sse2_cw
) & (MSVCRT__MCW_EM
| MSVCRT__MCW_RC
)) x86_cw
|= MSVCRT__EM_AMBIGUOUS
;
1099 FIXME( "not implemented\n" );
1104 /*********************************************************************
1105 * _controlfp (MSVCRT.@)
1107 unsigned int CDECL
_controlfp(unsigned int newval
, unsigned int mask
)
1109 return _control87( newval
, mask
& ~MSVCRT__EM_DENORMAL
);
1112 /*********************************************************************
1113 * _set_controlfp (MSVCRT.@)
1115 void CDECL
_set_controlfp( unsigned int newval
, unsigned int mask
)
1117 _controlfp( newval
, mask
);
1120 /*********************************************************************
1121 * _controlfp_s (MSVCRT.@)
1123 int CDECL
_controlfp_s(unsigned int *cur
, unsigned int newval
, unsigned int mask
)
1125 static const unsigned int all_flags
= (MSVCRT__MCW_EM
| MSVCRT__MCW_IC
| MSVCRT__MCW_RC
|
1126 MSVCRT__MCW_PC
| MSVCRT__MCW_DN
);
1129 if (!MSVCRT_CHECK_PMT( !(newval
& mask
& ~all_flags
) ))
1131 if (cur
) *cur
= _controlfp( 0, 0 ); /* retrieve it anyway */
1132 return MSVCRT_EINVAL
;
1134 val
= _controlfp( newval
, mask
);
1135 if (cur
) *cur
= val
;
1139 /*********************************************************************
1140 * _copysign (MSVCRT.@)
1142 double CDECL
MSVCRT__copysign(double num
, double sign
)
1144 /* FIXME: Behaviour for Nan/Inf? */
1146 return num
< 0.0 ? num
: -num
;
1147 return num
< 0.0 ? -num
: num
;
1150 /*********************************************************************
1151 * _finite (MSVCRT.@)
1153 int CDECL
MSVCRT__finite(double num
)
1155 return (finite(num
)?1:0); /* See comment for _isnan() */
1158 /*********************************************************************
1159 * _fpreset (MSVCRT.@)
1161 void CDECL
_fpreset(void)
1163 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1164 const unsigned int x86_cw
= 0x27f;
1165 __asm__
__volatile__( "fninit; fldcw %0" : : "m" (x86_cw
) );
1168 const unsigned long sse2_cw
= 0x1f80;
1169 __asm__
__volatile__( "ldmxcsr %0" : : "m" (sse2_cw
) );
1172 FIXME( "not implemented\n" );
1176 /*********************************************************************
1179 INT CDECL
MSVCRT__isnan(double num
)
1181 /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
1182 * Do the same, as the result may be used in calculations
1184 return isnan(num
) ? 1 : 0;
1187 /*********************************************************************
1190 double CDECL
MSVCRT__j0(double num
)
1192 /* FIXME: errno handling */
1196 /*********************************************************************
1199 double CDECL
MSVCRT__j1(double num
)
1201 /* FIXME: errno handling */
1205 /*********************************************************************
1208 double CDECL
MSVCRT__jn(int n
, double num
)
1210 /* FIXME: errno handling */
1214 /*********************************************************************
1217 double CDECL
MSVCRT__y0(double num
)
1220 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1222 if (MSVCRT__fpclass(retval
) == MSVCRT__FPCLASS_NINF
)
1224 *MSVCRT__errno() = MSVCRT_EDOM
;
1230 /*********************************************************************
1233 double CDECL
MSVCRT__y1(double num
)
1236 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1238 if (MSVCRT__fpclass(retval
) == MSVCRT__FPCLASS_NINF
)
1240 *MSVCRT__errno() = MSVCRT_EDOM
;
1246 /*********************************************************************
1249 double CDECL
MSVCRT__yn(int order
, double num
)
1252 if (!finite(num
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1253 retval
= yn(order
,num
);
1254 if (MSVCRT__fpclass(retval
) == MSVCRT__FPCLASS_NINF
)
1256 *MSVCRT__errno() = MSVCRT_EDOM
;
1262 /*********************************************************************
1263 * _nextafter (MSVCRT.@)
1265 double CDECL
MSVCRT__nextafter(double num
, double next
)
1268 if (!finite(num
) || !finite(next
)) *MSVCRT__errno() = MSVCRT_EDOM
;
1269 retval
= nextafter(num
,next
);
1273 /*********************************************************************
1276 char * CDECL
_ecvt( double number
, int ndigits
, int *decpt
, int *sign
)
1279 thread_data_t
*data
= msvcrt_get_thread_data();
1280 /* FIXME: check better for overflow (native supports over 300 chars) */
1281 ndigits
= min( ndigits
, 80 - 7); /* 7 : space for dec point, 1 for "e",
1282 * 4 for exponent and one for
1283 * terminating '\0' */
1284 if (!data
->efcvt_buffer
)
1285 data
->efcvt_buffer
= MSVCRT_malloc( 80 ); /* ought to be enough */
1292 /* handle cases with zero ndigits or less */
1294 if( prec
< 1) prec
= 2;
1295 len
= snprintf(data
->efcvt_buffer
, 80, "%.*le", prec
- 1, number
);
1296 /* take the decimal "point away */
1298 memmove( data
->efcvt_buffer
+ 1, data
->efcvt_buffer
+ 2, len
- 1 );
1299 /* take the exponential "e" out */
1300 data
->efcvt_buffer
[ prec
] = '\0';
1301 /* read the exponent */
1302 sscanf( data
->efcvt_buffer
+ prec
+ 1, "%d", decpt
);
1304 /* adjust for some border cases */
1305 if( data
->efcvt_buffer
[0] == '0')/* value is zero */
1307 /* handle cases with zero ndigits or less */
1309 if( data
->efcvt_buffer
[ 0] >= '5')
1311 data
->efcvt_buffer
[ 0] = '\0';
1313 TRACE("out=\"%s\"\n",data
->efcvt_buffer
);
1314 return data
->efcvt_buffer
;
1317 /*********************************************************************
1318 * _ecvt_s (MSVCRT.@)
1320 int CDECL
_ecvt_s( char *buffer
, MSVCRT_size_t length
, double number
, int ndigits
, int *decpt
, int *sign
)
1324 const char infret
[] = "1#INF";
1326 if (!MSVCRT_CHECK_PMT(buffer
!= NULL
)) return MSVCRT_EINVAL
;
1327 if (!MSVCRT_CHECK_PMT(decpt
!= NULL
)) return MSVCRT_EINVAL
;
1328 if (!MSVCRT_CHECK_PMT(sign
!= NULL
)) return MSVCRT_EINVAL
;
1329 if (!MSVCRT_CHECK_PMT_ERR( length
> 2, MSVCRT_ERANGE
)) return MSVCRT_ERANGE
;
1330 if (!MSVCRT_CHECK_PMT_ERR(ndigits
< (int)length
- 1, MSVCRT_ERANGE
)) return MSVCRT_ERANGE
;
1332 /* special case - inf */
1333 if(number
== HUGE_VAL
|| number
== -HUGE_VAL
)
1335 memset(buffer
, '0', ndigits
);
1336 memcpy(buffer
, infret
, min(ndigits
, sizeof(infret
) - 1 ) );
1337 buffer
[ndigits
] = '\0';
1339 if(number
== -HUGE_VAL
)
1345 /* handle cases with zero ndigits or less */
1347 if( prec
< 1) prec
= 2;
1348 result
= MSVCRT_malloc(prec
+ 7);
1355 len
= snprintf(result
, prec
+ 7, "%.*le", prec
- 1, number
);
1356 /* take the decimal "point away */
1358 memmove( result
+ 1, result
+ 2, len
- 1 );
1359 /* take the exponential "e" out */
1360 result
[ prec
] = '\0';
1361 /* read the exponent */
1362 sscanf( result
+ prec
+ 1, "%d", decpt
);
1364 /* adjust for some border cases */
1365 if( result
[0] == '0')/* value is zero */
1367 /* handle cases with zero ndigits or less */
1369 if( result
[ 0] >= '5')
1373 memcpy( buffer
, result
, max(ndigits
+ 1, 1) );
1374 MSVCRT_free( result
);
1378 /***********************************************************************
1381 char * CDECL
_fcvt( double number
, int ndigits
, int *decpt
, int *sign
)
1383 thread_data_t
*data
= msvcrt_get_thread_data();
1384 int stop
, dec1
, dec2
;
1385 char *ptr1
, *ptr2
, *first
;
1386 char buf
[80]; /* ought to be enough */
1388 if (!data
->efcvt_buffer
)
1389 data
->efcvt_buffer
= MSVCRT_malloc( 80 ); /* ought to be enough */
1397 snprintf(buf
, 80, "%.*f", ndigits
< 0 ? 0 : ndigits
, number
);
1399 ptr2
= data
->efcvt_buffer
;
1404 /* For numbers below the requested resolution, work out where
1405 the decimal point will be rather than finding it in the string */
1406 if (number
< 1.0 && number
> 0.0) {
1407 dec2
= log10(number
+ 1e-10);
1408 if (-dec2
<= ndigits
) dec2
= 0;
1411 /* If requested digits is zero or less, we will need to truncate
1412 * the returned string */
1414 stop
= strlen(buf
) + ndigits
;
1419 while (*ptr1
== '0') ptr1
++; /* Skip leading zeroes */
1420 while (*ptr1
!= '\0' && *ptr1
!= '.') {
1421 if (!first
) first
= ptr2
;
1422 if ((ptr1
- buf
) < stop
) {
1433 while (*ptr1
== '0') { /* Process leading zeroes */
1438 while (*ptr1
!= '\0') {
1439 if (!first
) first
= ptr2
;
1446 /* We never found a non-zero digit, then our number is either
1447 * smaller than the requested precision, or 0.0 */
1452 first
= data
->efcvt_buffer
;
1457 *decpt
= dec2
? dec2
: dec1
;
1461 /***********************************************************************
1462 * _fcvt_s (MSVCRT.@)
1464 int CDECL
_fcvt_s(char* outbuffer
, MSVCRT_size_t size
, double number
, int ndigits
, int *decpt
, int *sign
)
1466 int stop
, dec1
, dec2
;
1467 char *ptr1
, *ptr2
, *first
;
1468 char buf
[80]; /* ought to be enough */
1470 if (!outbuffer
|| !decpt
|| !sign
|| size
== 0)
1472 *MSVCRT__errno() = MSVCRT_EINVAL
;
1473 return MSVCRT_EINVAL
;
1482 snprintf(buf
, 80, "%.*f", ndigits
< 0 ? 0 : ndigits
, number
);
1489 /* For numbers below the requested resolution, work out where
1490 the decimal point will be rather than finding it in the string */
1491 if (number
< 1.0 && number
> 0.0) {
1492 dec2
= log10(number
+ 1e-10);
1493 if (-dec2
<= ndigits
) dec2
= 0;
1496 /* If requested digits is zero or less, we will need to truncate
1497 * the returned string */
1499 stop
= strlen(buf
) + ndigits
;
1504 while (*ptr1
== '0') ptr1
++; /* Skip leading zeroes */
1505 while (*ptr1
!= '\0' && *ptr1
!= '.') {
1506 if (!first
) first
= ptr2
;
1507 if ((ptr1
- buf
) < stop
) {
1521 while (*ptr1
== '0') { /* Process leading zeroes */
1522 if (number
== 0.0 && size
> 1) {
1530 while (*ptr1
!= '\0') {
1531 if (!first
) first
= ptr2
;
1541 /* We never found a non-zero digit, then our number is either
1542 * smaller than the requested precision, or 0.0 */
1543 if (!first
&& (number
<= 0.0))
1546 *decpt
= dec2
? dec2
: dec1
;
1550 /***********************************************************************
1553 char * CDECL
_gcvt( double number
, int ndigit
, char *buff
)
1556 *MSVCRT__errno() = MSVCRT_EINVAL
;
1561 *MSVCRT__errno() = MSVCRT_ERANGE
;
1565 MSVCRT_sprintf(buff
, "%.*g", ndigit
, number
);
1569 /***********************************************************************
1570 * _gcvt_s (MSVCRT.@)
1572 int CDECL
_gcvt_s(char *buff
, MSVCRT_size_t size
, double number
, int digits
)
1577 *MSVCRT__errno() = MSVCRT_EINVAL
;
1578 return MSVCRT_EINVAL
;
1581 if( digits
<0 || digits
>=size
) {
1585 *MSVCRT__errno() = MSVCRT_ERANGE
;
1586 return MSVCRT_ERANGE
;
1589 len
= MSVCRT__scprintf("%.*g", digits
, number
);
1592 *MSVCRT__errno() = MSVCRT_ERANGE
;
1593 return MSVCRT_ERANGE
;
1596 MSVCRT_sprintf(buff
, "%.*g", digits
, number
);
1600 #include <stdlib.h> /* div_t, ldiv_t */
1602 /*********************************************************************
1605 * [i386] Windows binary compatible - returns the struct in eax/edx.
1608 unsigned __int64 CDECL
MSVCRT_div(int num
, int denom
)
1610 div_t dt
= div(num
,denom
);
1611 return ((unsigned __int64
)dt
.rem
<< 32) | (unsigned int)dt
.quot
;
1614 /*********************************************************************
1617 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1619 MSVCRT_div_t CDECL
MSVCRT_div(int num
, int denom
)
1621 div_t dt
= div(num
,denom
);
1629 #endif /* ifdef __i386__ */
1632 /*********************************************************************
1635 * [i386] Windows binary compatible - returns the struct in eax/edx.
1638 unsigned __int64 CDECL
MSVCRT_ldiv(MSVCRT_long num
, MSVCRT_long denom
)
1640 ldiv_t ldt
= ldiv(num
,denom
);
1641 return ((unsigned __int64
)ldt
.rem
<< 32) | (MSVCRT_ulong
)ldt
.quot
;
1644 /*********************************************************************
1647 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1649 MSVCRT_ldiv_t CDECL
MSVCRT_ldiv(MSVCRT_long num
, MSVCRT_long denom
)
1651 ldiv_t result
= ldiv(num
,denom
);
1654 ret
.quot
= result
.quot
;
1655 ret
.rem
= result
.rem
;
1659 #endif /* ifdef __i386__ */
1663 /*********************************************************************
1664 * _adjust_fdiv (MSVCRT.@)
1665 * Used by the MSVC compiler to work around the Pentium FDIV bug.
1667 int MSVCRT__adjust_fdiv
= 0;
1669 /***********************************************************************
1670 * _adj_fdiv_m16i (MSVCRT.@)
1673 * I _think_ this function is intended to work around the Pentium
1676 void __stdcall
_adj_fdiv_m16i( short arg
)
1678 TRACE("(): stub\n");
1681 /***********************************************************************
1682 * _adj_fdiv_m32 (MSVCRT.@)
1685 * I _think_ this function is intended to work around the Pentium
1688 void __stdcall
_adj_fdiv_m32( unsigned int arg
)
1690 TRACE("(): stub\n");
1693 /***********************************************************************
1694 * _adj_fdiv_m32i (MSVCRT.@)
1697 * I _think_ this function is intended to work around the Pentium
1700 void __stdcall
_adj_fdiv_m32i( int arg
)
1702 TRACE("(): stub\n");
1705 /***********************************************************************
1706 * _adj_fdiv_m64 (MSVCRT.@)
1709 * I _think_ this function is intended to work around the Pentium
1712 void __stdcall
_adj_fdiv_m64( unsigned __int64 arg
)
1714 TRACE("(): stub\n");
1717 /***********************************************************************
1718 * _adj_fdiv_r (MSVCRT.@)
1720 * This function is likely to have the wrong number of arguments.
1723 * I _think_ this function is intended to work around the Pentium
1726 void _adj_fdiv_r(void)
1728 TRACE("(): stub\n");
1731 /***********************************************************************
1732 * _adj_fdivr_m16i (MSVCRT.@)
1735 * I _think_ this function is intended to work around the Pentium
1738 void __stdcall
_adj_fdivr_m16i( short arg
)
1740 TRACE("(): stub\n");
1743 /***********************************************************************
1744 * _adj_fdivr_m32 (MSVCRT.@)
1747 * I _think_ this function is intended to work around the Pentium
1750 void __stdcall
_adj_fdivr_m32( unsigned int arg
)
1752 TRACE("(): stub\n");
1755 /***********************************************************************
1756 * _adj_fdivr_m32i (MSVCRT.@)
1759 * I _think_ this function is intended to work around the Pentium
1762 void __stdcall
_adj_fdivr_m32i( int arg
)
1764 TRACE("(): stub\n");
1767 /***********************************************************************
1768 * _adj_fdivr_m64 (MSVCRT.@)
1771 * I _think_ this function is intended to work around the Pentium
1774 void __stdcall
_adj_fdivr_m64( unsigned __int64 arg
)
1776 TRACE("(): stub\n");
1779 /***********************************************************************
1780 * _adj_fpatan (MSVCRT.@)
1782 * This function is likely to have the wrong number of arguments.
1785 * I _think_ this function is intended to work around the Pentium
1788 void _adj_fpatan(void)
1790 TRACE("(): stub\n");
1793 /***********************************************************************
1794 * _adj_fprem (MSVCRT.@)
1796 * This function is likely to have the wrong number of arguments.
1799 * I _think_ this function is intended to work around the Pentium
1802 void _adj_fprem(void)
1804 TRACE("(): stub\n");
1807 /***********************************************************************
1808 * _adj_fprem1 (MSVCRT.@)
1810 * This function is likely to have the wrong number of arguments.
1813 * I _think_ this function is intended to work around the Pentium
1816 void _adj_fprem1(void)
1818 TRACE("(): stub\n");
1821 /***********************************************************************
1822 * _adj_fptan (MSVCRT.@)
1824 * This function is likely to have the wrong number of arguments.
1827 * I _think_ this function is intended to work around the Pentium
1830 void _adj_fptan(void)
1832 TRACE("(): stub\n");
1835 /***********************************************************************
1836 * _safe_fdiv (MSVCRT.@)
1838 * This function is likely to have the wrong number of arguments.
1841 * I _think_ this function is intended to work around the Pentium
1844 void _safe_fdiv(void)
1846 TRACE("(): stub\n");
1849 /***********************************************************************
1850 * _safe_fdivr (MSVCRT.@)
1852 * This function is likely to have the wrong number of arguments.
1855 * I _think_ this function is intended to work around the Pentium
1858 void _safe_fdivr(void)
1860 TRACE("(): stub\n");
1863 /***********************************************************************
1864 * _safe_fprem (MSVCRT.@)
1866 * This function is likely to have the wrong number of arguments.
1869 * I _think_ this function is intended to work around the Pentium
1872 void _safe_fprem(void)
1874 TRACE("(): stub\n");
1877 /***********************************************************************
1878 * _safe_fprem1 (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 _safe_fprem1(void)
1889 TRACE("(): stub\n");
1892 /***********************************************************************
1893 * __libm_sse2_acos (MSVCRT.@)
1895 void __cdecl
__libm_sse2_acos(void)
1898 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
1900 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
1903 /***********************************************************************
1904 * __libm_sse2_acosf (MSVCRT.@)
1906 void __cdecl
__libm_sse2_acosf(void)
1909 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
1911 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
1914 /***********************************************************************
1915 * __libm_sse2_asin (MSVCRT.@)
1917 void __cdecl
__libm_sse2_asin(void)
1920 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
1922 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
1925 /***********************************************************************
1926 * __libm_sse2_asinf (MSVCRT.@)
1928 void __cdecl
__libm_sse2_asinf(void)
1931 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
1933 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
1936 /***********************************************************************
1937 * __libm_sse2_atan (MSVCRT.@)
1939 void __cdecl
__libm_sse2_atan(void)
1942 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
1944 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
1947 /***********************************************************************
1948 * __libm_sse2_atan2 (MSVCRT.@)
1950 void __cdecl
__libm_sse2_atan2(void)
1953 __asm__
__volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1
), "=m" (d2
) );
1954 d1
= atan2( d1
, d2
);
1955 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d1
) );
1958 /***********************************************************************
1959 * __libm_sse2_atanf (MSVCRT.@)
1961 void __cdecl
__libm_sse2_atanf(void)
1964 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
1966 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
1969 /***********************************************************************
1970 * __libm_sse2_cos (MSVCRT.@)
1972 void __cdecl
__libm_sse2_cos(void)
1975 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
1977 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
1980 /***********************************************************************
1981 * __libm_sse2_cosf (MSVCRT.@)
1983 void __cdecl
__libm_sse2_cosf(void)
1986 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
1988 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
1991 /***********************************************************************
1992 * __libm_sse2_exp (MSVCRT.@)
1994 void __cdecl
__libm_sse2_exp(void)
1997 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
1999 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2002 /***********************************************************************
2003 * __libm_sse2_expf (MSVCRT.@)
2005 void __cdecl
__libm_sse2_expf(void)
2008 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2010 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2013 /***********************************************************************
2014 * __libm_sse2_log (MSVCRT.@)
2016 void __cdecl
__libm_sse2_log(void)
2019 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2021 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2024 /***********************************************************************
2025 * __libm_sse2_log10 (MSVCRT.@)
2027 void __cdecl
__libm_sse2_log10(void)
2030 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2032 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2035 /***********************************************************************
2036 * __libm_sse2_log10f (MSVCRT.@)
2038 void __cdecl
__libm_sse2_log10f(void)
2041 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2043 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2046 /***********************************************************************
2047 * __libm_sse2_logf (MSVCRT.@)
2049 void __cdecl
__libm_sse2_logf(void)
2052 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2054 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2057 /***********************************************************************
2058 * __libm_sse2_pow (MSVCRT.@)
2060 void __cdecl
__libm_sse2_pow(void)
2063 __asm__
__volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1
), "=m" (d2
) );
2065 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d1
) );
2068 /***********************************************************************
2069 * __libm_sse2_powf (MSVCRT.@)
2071 void __cdecl
__libm_sse2_powf(void)
2074 __asm__
__volatile__( "movd %%xmm0,%0; movd %%xmm1,%1" : "=g" (f1
), "=g" (f2
) );
2075 f1
= powf( f1
, f2
);
2076 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f1
) );
2079 /***********************************************************************
2080 * __libm_sse2_sin (MSVCRT.@)
2082 void __cdecl
__libm_sse2_sin(void)
2085 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2087 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2090 /***********************************************************************
2091 * __libm_sse2_sinf (MSVCRT.@)
2093 void __cdecl
__libm_sse2_sinf(void)
2096 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2098 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2101 /***********************************************************************
2102 * __libm_sse2_tan (MSVCRT.@)
2104 void __cdecl
__libm_sse2_tan(void)
2107 __asm__
__volatile__( "movq %%xmm0,%0" : "=m" (d
) );
2109 __asm__
__volatile__( "movq %0,%%xmm0" : : "m" (d
) );
2112 /***********************************************************************
2113 * __libm_sse2_tanf (MSVCRT.@)
2115 void __cdecl
__libm_sse2_tanf(void)
2118 __asm__
__volatile__( "movd %%xmm0,%0" : "=g" (f
) );
2120 __asm__
__volatile__( "movd %0,%%xmm0" : : "g" (f
) );
2123 #endif /* __i386__ */