msvcrt: Reuse standard file descriptors after closing them.
[wine] / dlls / msvcrt / math.c
1 /*
2  * msvcrt.dll math functions
3  *
4  * Copyright 2000 Jon Griffiths
5  *
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.
10  *
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.
15  *
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
19  */
20 #include "config.h"
21
22 #include <stdio.h>
23 #define __USE_ISOC9X 1
24 #define __USE_ISOC99 1
25 #include <math.h>
26 #ifdef HAVE_IEEEFP_H
27 #include <ieeefp.h>
28 #endif
29
30 #include "msvcrt.h"
31
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
35
36 #ifndef HAVE_FINITE
37 #ifndef finite /* Could be a macro */
38 #ifdef isfinite
39 #define finite(x) isfinite(x)
40 #else
41 #define finite(x) (!isnan(x)) /* At least catch some cases */
42 #endif
43 #endif
44 #endif
45
46 #ifndef signbit
47 #define signbit(x) 0
48 #endif
49
50 typedef int (CDECL *MSVCRT_matherr_func)(struct MSVCRT__exception *);
51
52 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
53
54 static BOOL sse2_supported;
55 static BOOL sse2_enabled;
56
57 void msvcrt_init_math(void)
58 {
59     sse2_supported = sse2_enabled = IsProcessorFeaturePresent( PF_XMMI64_INSTRUCTIONS_AVAILABLE );
60 }
61
62 /*********************************************************************
63  *      _set_SSE2_enable (MSVCRT.@)
64  */
65 int CDECL MSVCRT__set_SSE2_enable(int flag)
66 {
67     sse2_enabled = flag && sse2_supported;
68     return sse2_enabled;
69 }
70
71 #ifdef __x86_64__
72
73 /*********************************************************************
74  *      _chgsignf (MSVCRT.@)
75  */
76 float CDECL MSVCRT__chgsignf( float num )
77 {
78     /* FIXME: +-infinity,Nan not tested */
79     return -num;
80 }
81
82 /*********************************************************************
83  *      _copysignf (MSVCRT.@)
84  */
85 float CDECL MSVCRT__copysignf( float num, float sign )
86 {
87     /* FIXME: Behaviour for Nan/Inf? */
88     if (sign < 0.0)
89         return num < 0.0 ? num : -num;
90     return num < 0.0 ? -num : num;
91 }
92
93 /*********************************************************************
94  *      _finitef (MSVCRT.@)
95  */
96 int CDECL MSVCRT__finitef( float num )
97 {
98     return finitef(num) != 0; /* See comment for _isnan() */
99 }
100
101 /*********************************************************************
102  *      _isnanf (MSVCRT.@)
103  */
104 INT CDECL MSVCRT__isnanf( float num )
105 {
106     /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
107      * Do the same, as the result may be used in calculations
108      */
109     return isnanf(num) != 0;
110 }
111
112 /*********************************************************************
113  *      _logbf (MSVCRT.@)
114  */
115 float CDECL MSVCRT__logbf( float num )
116 {
117     if (!finitef(num)) *MSVCRT__errno() = MSVCRT_EDOM;
118     return logbf(num);
119 }
120
121 /*********************************************************************
122  *      _nextafterf (MSVCRT.@)
123  */
124 float CDECL MSVCRT__nextafterf( float num, float next )
125 {
126     if (!finitef(num) || !finitef(next)) *MSVCRT__errno() = MSVCRT_EDOM;
127     return nextafterf( num, next );
128 }
129
130 /*********************************************************************
131  *      MSVCRT_acosf (MSVCRT.@)
132  */
133 float CDECL MSVCRT_acosf( float x )
134 {
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);
142 }
143
144 /*********************************************************************
145  *      MSVCRT_asinf (MSVCRT.@)
146  */
147 float CDECL MSVCRT_asinf( float x )
148 {
149   if (x < -1.0 || x > 1.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
150   return atan2f(x, sqrtf((1 - x) * (1 + x)));
151 }
152
153 /*********************************************************************
154  *      MSVCRT_atanf (MSVCRT.@)
155  */
156 float CDECL MSVCRT_atanf( float x )
157 {
158   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
159   return atanf(x);
160 }
161
162 /*********************************************************************
163  *              MSVCRT_atan2f (MSVCRT.@)
164  */
165 float CDECL MSVCRT_atan2f( float x, float y )
166 {
167   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
168   return atan2f(x,y);
169 }
170
171 /*********************************************************************
172  *      MSVCRT_cosf (MSVCRT.@)
173  */
174 float CDECL MSVCRT_cosf( float x )
175 {
176   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
177   return cosf(x);
178 }
179
180 /*********************************************************************
181  *      MSVCRT_coshf (MSVCRT.@)
182  */
183 float CDECL MSVCRT_coshf( float x )
184 {
185   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
186   return coshf(x);
187 }
188
189 /*********************************************************************
190  *      MSVCRT_expf (MSVCRT.@)
191  */
192 float CDECL MSVCRT_expf( float x )
193 {
194   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
195   return expf(x);
196 }
197
198 /*********************************************************************
199  *      MSVCRT_fmodf (MSVCRT.@)
200  */
201 float CDECL MSVCRT_fmodf( float x, float y )
202 {
203   if (!finitef(x) || !finitef(y)) *MSVCRT__errno() = MSVCRT_EDOM;
204   return fmodf(x,y);
205 }
206
207 /*********************************************************************
208  *      MSVCRT_logf (MSVCRT.@)
209  */
210 float CDECL MSVCRT_logf( float x)
211 {
212   if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
213   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
214   return logf(x);
215 }
216
217 /*********************************************************************
218  *      MSVCRT_log10f (MSVCRT.@)
219  */
220 float CDECL MSVCRT_log10f( float x )
221 {
222   if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
223   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
224   return log10f(x);
225 }
226
227 /*********************************************************************
228  *      MSVCRT_powf (MSVCRT.@)
229  */
230 float CDECL MSVCRT_powf( float x, float y )
231 {
232   /* FIXME: If x < 0 and y is not integral, set EDOM */
233   float z = powf(x,y);
234   if (!finitef(z)) *MSVCRT__errno() = MSVCRT_EDOM;
235   return z;
236 }
237
238 /*********************************************************************
239  *      MSVCRT_sinf (MSVCRT.@)
240  */
241 float CDECL MSVCRT_sinf( float x )
242 {
243   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
244   return sinf(x);
245 }
246
247 /*********************************************************************
248  *      MSVCRT_sinhf (MSVCRT.@)
249  */
250 float CDECL MSVCRT_sinhf( float x )
251 {
252   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
253   return sinhf(x);
254 }
255
256 /*********************************************************************
257  *      MSVCRT_sqrtf (MSVCRT.@)
258  */
259 float CDECL MSVCRT_sqrtf( float x )
260 {
261   if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
262   return sqrtf(x);
263 }
264
265 /*********************************************************************
266  *      MSVCRT_tanf (MSVCRT.@)
267  */
268 float CDECL MSVCRT_tanf( float x )
269 {
270   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
271   return tanf(x);
272 }
273
274 /*********************************************************************
275  *      MSVCRT_tanhf (MSVCRT.@)
276  */
277 float CDECL MSVCRT_tanhf( float x )
278 {
279   if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
280   return tanhf(x);
281 }
282
283 /*********************************************************************
284  *      ceilf (MSVCRT.@)
285  */
286 float CDECL MSVCRT_ceilf( float x )
287 {
288   return ceilf(x);
289 }
290
291 /*********************************************************************
292  *      floorf (MSVCRT.@)
293  */
294 float CDECL MSVCRT_floorf( float x )
295 {
296   return floorf(x);
297 }
298
299 /*********************************************************************
300  *      frexpf (MSVCRT.@)
301  */
302 float CDECL MSVCRT_frexpf( float x, int *exp )
303 {
304   return frexpf( x, exp );
305 }
306
307 /*********************************************************************
308  *      _scalbf (MSVCRT.@)
309  */
310 float CDECL MSVCRT__scalbf(float num, MSVCRT_long power)
311 {
312   if (!finitef(num)) *MSVCRT__errno() = MSVCRT_EDOM;
313   return ldexpf(num, power);
314 }
315
316 /*********************************************************************
317  *      modff (MSVCRT.@)
318  */
319 double CDECL MSVCRT_modff( float x, float *iptr )
320 {
321   return modff( x, iptr );
322 }
323
324 #endif
325
326 /*********************************************************************
327  *              MSVCRT_acos (MSVCRT.@)
328  */
329 double CDECL MSVCRT_acos( double x )
330 {
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);
338 }
339
340 /*********************************************************************
341  *              MSVCRT_asin (MSVCRT.@)
342  */
343 double CDECL MSVCRT_asin( double x )
344 {
345   if (x < -1.0 || x > 1.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
346   return atan2(x, sqrt((1 - x) * (1 + x)));
347 }
348
349 /*********************************************************************
350  *              MSVCRT_atan (MSVCRT.@)
351  */
352 double CDECL MSVCRT_atan( double x )
353 {
354   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
355   return atan(x);
356 }
357
358 /*********************************************************************
359  *              MSVCRT_atan2 (MSVCRT.@)
360  */
361 double CDECL MSVCRT_atan2( double x, double y )
362 {
363   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
364   return atan2(x,y);
365 }
366
367 /*********************************************************************
368  *              MSVCRT_cos (MSVCRT.@)
369  */
370 double CDECL MSVCRT_cos( double x )
371 {
372   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
373   return cos(x);
374 }
375
376 /*********************************************************************
377  *              MSVCRT_cosh (MSVCRT.@)
378  */
379 double CDECL MSVCRT_cosh( double x )
380 {
381   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
382   return cosh(x);
383 }
384
385 /*********************************************************************
386  *              MSVCRT_exp (MSVCRT.@)
387  */
388 double CDECL MSVCRT_exp( double x )
389 {
390   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
391   return exp(x);
392 }
393
394 /*********************************************************************
395  *              MSVCRT_fmod (MSVCRT.@)
396  */
397 double CDECL MSVCRT_fmod( double x, double y )
398 {
399   if (!finite(x) || !finite(y)) *MSVCRT__errno() = MSVCRT_EDOM;
400   return fmod(x,y);
401 }
402
403 /*********************************************************************
404  *              MSVCRT_log (MSVCRT.@)
405  */
406 double CDECL MSVCRT_log( double x)
407 {
408   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
409   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
410   return log(x);
411 }
412
413 /*********************************************************************
414  *              MSVCRT_log10 (MSVCRT.@)
415  */
416 double CDECL MSVCRT_log10( double x )
417 {
418   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
419   if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
420   return log10(x);
421 }
422
423 /*********************************************************************
424  *              MSVCRT_pow (MSVCRT.@)
425  */
426 double CDECL MSVCRT_pow( double x, double y )
427 {
428   /* FIXME: If x < 0 and y is not integral, set EDOM */
429   double z = pow(x,y);
430   if (!finite(z)) *MSVCRT__errno() = MSVCRT_EDOM;
431   return z;
432 }
433
434 /*********************************************************************
435  *              MSVCRT_sin (MSVCRT.@)
436  */
437 double CDECL MSVCRT_sin( double x )
438 {
439   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
440   return sin(x);
441 }
442
443 /*********************************************************************
444  *              MSVCRT_sinh (MSVCRT.@)
445  */
446 double CDECL MSVCRT_sinh( double x )
447 {
448   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
449   return sinh(x);
450 }
451
452 /*********************************************************************
453  *              MSVCRT_sqrt (MSVCRT.@)
454  */
455 double CDECL MSVCRT_sqrt( double x )
456 {
457   if (x < 0.0 || !finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
458   return sqrt(x);
459 }
460
461 /*********************************************************************
462  *              MSVCRT_tan (MSVCRT.@)
463  */
464 double CDECL MSVCRT_tan( double x )
465 {
466   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
467   return tan(x);
468 }
469
470 /*********************************************************************
471  *              MSVCRT_tanh (MSVCRT.@)
472  */
473 double CDECL MSVCRT_tanh( double x )
474 {
475   if (!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
476   return tanh(x);
477 }
478
479
480 #if defined(__GNUC__) && defined(__i386__)
481
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) : )
487
488 /*********************************************************************
489  *              _CIacos (MSVCRT.@)
490  */
491 double CDECL _CIacos(void)
492 {
493   FPU_DOUBLE(x);
494   return MSVCRT_acos(x);
495 }
496
497 /*********************************************************************
498  *              _CIasin (MSVCRT.@)
499  */
500 double CDECL _CIasin(void)
501 {
502   FPU_DOUBLE(x);
503   return MSVCRT_asin(x);
504 }
505
506 /*********************************************************************
507  *              _CIatan (MSVCRT.@)
508  */
509 double CDECL _CIatan(void)
510 {
511   FPU_DOUBLE(x);
512   return MSVCRT_atan(x);
513 }
514
515 /*********************************************************************
516  *              _CIatan2 (MSVCRT.@)
517  */
518 double CDECL _CIatan2(void)
519 {
520   FPU_DOUBLES(x,y);
521   return MSVCRT_atan2(x,y);
522 }
523
524 /*********************************************************************
525  *              _CIcos (MSVCRT.@)
526  */
527 double CDECL _CIcos(void)
528 {
529   FPU_DOUBLE(x);
530   return MSVCRT_cos(x);
531 }
532
533 /*********************************************************************
534  *              _CIcosh (MSVCRT.@)
535  */
536 double CDECL _CIcosh(void)
537 {
538   FPU_DOUBLE(x);
539   return MSVCRT_cosh(x);
540 }
541
542 /*********************************************************************
543  *              _CIexp (MSVCRT.@)
544  */
545 double CDECL _CIexp(void)
546 {
547   FPU_DOUBLE(x);
548   return MSVCRT_exp(x);
549 }
550
551 /*********************************************************************
552  *              _CIfmod (MSVCRT.@)
553  */
554 double CDECL _CIfmod(void)
555 {
556   FPU_DOUBLES(x,y);
557   return MSVCRT_fmod(x,y);
558 }
559
560 /*********************************************************************
561  *              _CIlog (MSVCRT.@)
562  */
563 double CDECL _CIlog(void)
564 {
565   FPU_DOUBLE(x);
566   return MSVCRT_log(x);
567 }
568
569 /*********************************************************************
570  *              _CIlog10 (MSVCRT.@)
571  */
572 double CDECL _CIlog10(void)
573 {
574   FPU_DOUBLE(x);
575   return MSVCRT_log10(x);
576 }
577
578 /*********************************************************************
579  *              _CIpow (MSVCRT.@)
580  */
581 double CDECL _CIpow(void)
582 {
583   FPU_DOUBLES(x,y);
584   return MSVCRT_pow(x,y);
585 }
586
587 /*********************************************************************
588  *              _CIsin (MSVCRT.@)
589  */
590 double CDECL _CIsin(void)
591 {
592   FPU_DOUBLE(x);
593   return MSVCRT_sin(x);
594 }
595
596 /*********************************************************************
597  *              _CIsinh (MSVCRT.@)
598  */
599 double CDECL _CIsinh(void)
600 {
601   FPU_DOUBLE(x);
602   return MSVCRT_sinh(x);
603 }
604
605 /*********************************************************************
606  *              _CIsqrt (MSVCRT.@)
607  */
608 double CDECL _CIsqrt(void)
609 {
610   FPU_DOUBLE(x);
611   return MSVCRT_sqrt(x);
612 }
613
614 /*********************************************************************
615  *              _CItan (MSVCRT.@)
616  */
617 double CDECL _CItan(void)
618 {
619   FPU_DOUBLE(x);
620   return MSVCRT_tan(x);
621 }
622
623 /*********************************************************************
624  *              _CItanh (MSVCRT.@)
625  */
626 double CDECL _CItanh(void)
627 {
628   FPU_DOUBLE(x);
629   return MSVCRT_tanh(x);
630 }
631
632 /*********************************************************************
633  *                  _ftol   (MSVCRT.@)
634  */
635 LONGLONG CDECL MSVCRT__ftol(void)
636 {
637     FPU_DOUBLE(x);
638     return (LONGLONG)x;
639 }
640
641 #endif /* defined(__GNUC__) && defined(__i386__) */
642
643 /*********************************************************************
644  *              _fpclass (MSVCRT.@)
645  */
646 int CDECL MSVCRT__fpclass(double num)
647 {
648 #if defined(HAVE_FPCLASS) || defined(fpclass)
649   switch (fpclass( num ))
650   {
651 #ifdef FP_SNAN
652   case FP_SNAN:  return MSVCRT__FPCLASS_SNAN;
653 #endif
654 #ifdef FP_QNAN
655   case FP_QNAN:  return MSVCRT__FPCLASS_QNAN;
656 #endif
657 #ifdef FP_NINF
658   case FP_NINF:  return MSVCRT__FPCLASS_NINF;
659 #endif
660 #ifdef FP_PINF
661   case FP_PINF:  return MSVCRT__FPCLASS_PINF;
662 #endif
663 #ifdef FP_NDENORM
664   case FP_NDENORM: return MSVCRT__FPCLASS_ND;
665 #endif
666 #ifdef FP_PDENORM
667   case FP_PDENORM: return MSVCRT__FPCLASS_PD;
668 #endif
669 #ifdef FP_NZERO
670   case FP_NZERO: return MSVCRT__FPCLASS_NZ;
671 #endif
672 #ifdef FP_PZERO
673   case FP_PZERO: return MSVCRT__FPCLASS_PZ;
674 #endif
675 #ifdef FP_NNORM
676   case FP_NNORM: return MSVCRT__FPCLASS_NN;
677 #endif
678 #ifdef FP_PNORM
679   case FP_PNORM: return MSVCRT__FPCLASS_PN;
680 #endif
681   default: return MSVCRT__FPCLASS_PN;
682   }
683 #elif defined (fpclassify)
684   switch (fpclassify( num ))
685   {
686   case FP_NAN: return MSVCRT__FPCLASS_QNAN;
687   case FP_INFINITE: return signbit(num) ? MSVCRT__FPCLASS_NINF : MSVCRT__FPCLASS_PINF;
688   case FP_SUBNORMAL: return signbit(num) ?MSVCRT__FPCLASS_ND : MSVCRT__FPCLASS_PD;
689   case FP_ZERO: return signbit(num) ? MSVCRT__FPCLASS_NZ : MSVCRT__FPCLASS_PZ;
690   }
691   return signbit(num) ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN;
692 #else
693   if (!finite(num))
694     return MSVCRT__FPCLASS_QNAN;
695   return num == 0.0 ? MSVCRT__FPCLASS_PZ : (num < 0 ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN);
696 #endif
697 }
698
699 /*********************************************************************
700  *              _rotl (MSVCRT.@)
701  */
702 unsigned int CDECL _rotl(unsigned int num, int shift)
703 {
704   shift &= 31;
705   return (num << shift) | (num >> (32-shift));
706 }
707
708 /*********************************************************************
709  *              _lrotl (MSVCRT.@)
710  */
711 MSVCRT_ulong CDECL MSVCRT__lrotl(MSVCRT_ulong num, int shift)
712 {
713   shift &= 0x1f;
714   return (num << shift) | (num >> (32-shift));
715 }
716
717 /*********************************************************************
718  *              _lrotr (MSVCRT.@)
719  */
720 MSVCRT_ulong CDECL MSVCRT__lrotr(MSVCRT_ulong num, int shift)
721 {
722   shift &= 0x1f;
723   return (num >> shift) | (num << (32-shift));
724 }
725
726 /*********************************************************************
727  *              _rotr (MSVCRT.@)
728  */
729 unsigned int CDECL _rotr(unsigned int num, int shift)
730 {
731     shift &= 0x1f;
732     return (num >> shift) | (num << (32-shift));
733 }
734
735 /*********************************************************************
736  *              _rotl64 (MSVCRT.@)
737  */
738 unsigned __int64 CDECL _rotl64(unsigned __int64 num, int shift)
739 {
740   shift &= 63;
741   return (num << shift) | (num >> (64-shift));
742 }
743
744 /*********************************************************************
745  *              _rotr64 (MSVCRT.@)
746  */
747 unsigned __int64 CDECL _rotr64(unsigned __int64 num, int shift)
748 {
749     shift &= 63;
750     return (num >> shift) | (num << (64-shift));
751 }
752
753 /*********************************************************************
754  *              abs (MSVCRT.@)
755  */
756 int CDECL MSVCRT_abs( int n )
757 {
758     return n >= 0 ? n : -n;
759 }
760
761 /*********************************************************************
762  *              labs (MSVCRT.@)
763  */
764 MSVCRT_long CDECL MSVCRT_labs( MSVCRT_long n )
765 {
766     return n >= 0 ? n : -n;
767 }
768
769 /*********************************************************************
770  *              _abs64 (MSVCRT.@)
771  */
772 __int64 CDECL _abs64( __int64 n )
773 {
774     return n >= 0 ? n : -n;
775 }
776
777 /*********************************************************************
778  *              _logb (MSVCRT.@)
779  */
780 double CDECL MSVCRT__logb(double num)
781 {
782   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
783   return logb(num);
784 }
785
786 /*********************************************************************
787  *              _scalb (MSVCRT.@)
788  */
789 double CDECL MSVCRT__scalb(double num, MSVCRT_long power)
790 {
791   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
792   return ldexp(num, power);
793 }
794
795 /*********************************************************************
796  *              _hypot (MSVCRT.@)
797  */
798 double CDECL _hypot(double x, double y)
799 {
800   /* FIXME: errno handling */
801   return hypot( x, y );
802 }
803
804 /*********************************************************************
805  *      _hypotf (MSVCRT.@)
806  */
807 float CDECL MSVCRT__hypotf(float x, float y)
808 {
809   /* FIXME: errno handling */
810   return hypotf( x, y );
811 }
812
813 /*********************************************************************
814  *              ceil (MSVCRT.@)
815  */
816 double CDECL MSVCRT_ceil( double x )
817 {
818   return ceil(x);
819 }
820
821 /*********************************************************************
822  *              floor (MSVCRT.@)
823  */
824 double CDECL MSVCRT_floor( double x )
825 {
826   return floor(x);
827 }
828
829 /*********************************************************************
830  *              fabs (MSVCRT.@)
831  */
832 double CDECL MSVCRT_fabs( double x )
833 {
834   return fabs(x);
835 }
836
837 /*********************************************************************
838  *              frexp (MSVCRT.@)
839  */
840 double CDECL MSVCRT_frexp( double x, int *exp )
841 {
842   return frexp( x, exp );
843 }
844
845 /*********************************************************************
846  *              modf (MSVCRT.@)
847  */
848 double CDECL MSVCRT_modf( double x, double *iptr )
849 {
850   return modf( x, iptr );
851 }
852
853 /*********************************************************************
854  *              _matherr (MSVCRT.@)
855  */
856 int CDECL MSVCRT__matherr(struct MSVCRT__exception *e)
857 {
858   if (e)
859     TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
860           e->retval);
861   else
862     TRACE("(null)\n");
863   if (MSVCRT_default_matherr_func)
864     return MSVCRT_default_matherr_func(e);
865   ERR(":Unhandled math error!\n");
866   return 0;
867 }
868
869 /*********************************************************************
870  *              __setusermatherr (MSVCRT.@)
871  */
872 void CDECL MSVCRT___setusermatherr(MSVCRT_matherr_func func)
873 {
874   MSVCRT_default_matherr_func = func;
875   TRACE(":new matherr handler %p\n", func);
876 }
877
878 /**********************************************************************
879  *              _statusfp2 (MSVCRT.@)
880  *
881  * Not exported by native msvcrt, added in msvcr80.
882  */
883 #if defined(__i386__) || defined(__x86_64__)
884 void CDECL _statusfp2( unsigned int *x86_sw, unsigned int *sse2_sw )
885 {
886 #ifdef __GNUC__
887     unsigned int flags;
888     unsigned long fpword;
889
890     if (x86_sw)
891     {
892         __asm__ __volatile__( "fstsw %0" : "=m" (fpword) );
893         flags = 0;
894         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
895         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
896         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
897         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
898         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
899         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
900         *x86_sw = flags;
901     }
902
903     if (!sse2_sw) return;
904
905     if (sse2_supported)
906     {
907         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
908         flags = 0;
909         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
910         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
911         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
912         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
913         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
914         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
915         *sse2_sw = flags;
916     }
917     else *sse2_sw = 0;
918 #else
919     FIXME( "not implemented\n" );
920 #endif
921 }
922 #endif
923
924 /**********************************************************************
925  *              _statusfp (MSVCRT.@)
926  */
927 unsigned int CDECL _statusfp(void)
928 {
929 #if defined(__i386__) || defined(__x86_64__)
930     unsigned int x86_sw, sse2_sw;
931
932     _statusfp2( &x86_sw, &sse2_sw );
933     /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
934     return x86_sw | sse2_sw;
935 #else
936     FIXME( "not implemented\n" );
937     return 0;
938 #endif
939 }
940
941 /*********************************************************************
942  *              _clearfp (MSVCRT.@)
943  */
944 unsigned int CDECL _clearfp(void)
945 {
946     unsigned int flags = 0;
947 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
948     unsigned long fpword;
949
950     __asm__ __volatile__( "fnstsw %0; fnclex" : "=m" (fpword) );
951     if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
952     if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
953     if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
954     if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
955     if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
956     if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
957
958     if (sse2_supported)
959     {
960         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
961         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
962         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
963         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
964         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
965         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
966         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
967         fpword &= ~0x3f;
968         __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
969     }
970 #else
971     FIXME( "not implemented\n" );
972 #endif
973     return flags;
974 }
975
976 /*********************************************************************
977  *              __fpecode (MSVCRT.@)
978  */
979 int * CDECL __fpecode(void)
980 {
981     return &msvcrt_get_thread_data()->fpecode;
982 }
983
984 /*********************************************************************
985  *              ldexp (MSVCRT.@)
986  */
987 double CDECL MSVCRT_ldexp(double num, MSVCRT_long exp)
988 {
989   double z = ldexp(num,exp);
990
991   if (!finite(z))
992     *MSVCRT__errno() = MSVCRT_ERANGE;
993   else if (z == 0 && signbit(z))
994     z = 0.0; /* Convert -0 -> +0 */
995   return z;
996 }
997
998 /*********************************************************************
999  *              _cabs (MSVCRT.@)
1000  */
1001 double CDECL MSVCRT__cabs(struct MSVCRT__complex num)
1002 {
1003   return sqrt(num.x * num.x + num.y * num.y);
1004 }
1005
1006 /*********************************************************************
1007  *              _chgsign (MSVCRT.@)
1008  */
1009 double CDECL MSVCRT__chgsign(double num)
1010 {
1011   /* FIXME: +-infinity,Nan not tested */
1012   return -num;
1013 }
1014
1015 /*********************************************************************
1016  *              __control87_2 (MSVCRT.@)
1017  *
1018  * Not exported by native msvcrt, added in msvcr80.
1019  */
1020 #if defined(__i386__) || defined(__x86_64__)
1021 int CDECL __control87_2( unsigned int newval, unsigned int mask,
1022                          unsigned int *x86_cw, unsigned int *sse2_cw )
1023 {
1024 #ifdef __GNUC__
1025     unsigned long fpword;
1026     unsigned int flags;
1027
1028     if (x86_cw)
1029     {
1030         __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
1031
1032         /* Convert into mask constants */
1033         flags = 0;
1034         if (fpword & 0x1)  flags |= MSVCRT__EM_INVALID;
1035         if (fpword & 0x2)  flags |= MSVCRT__EM_DENORMAL;
1036         if (fpword & 0x4)  flags |= MSVCRT__EM_ZERODIVIDE;
1037         if (fpword & 0x8)  flags |= MSVCRT__EM_OVERFLOW;
1038         if (fpword & 0x10) flags |= MSVCRT__EM_UNDERFLOW;
1039         if (fpword & 0x20) flags |= MSVCRT__EM_INEXACT;
1040         switch (fpword & 0xc00)
1041         {
1042         case 0xc00: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1043         case 0x800: flags |= MSVCRT__RC_UP; break;
1044         case 0x400: flags |= MSVCRT__RC_DOWN; break;
1045         }
1046         switch (fpword & 0x300)
1047         {
1048         case 0x0:   flags |= MSVCRT__PC_24; break;
1049         case 0x200: flags |= MSVCRT__PC_53; break;
1050         case 0x300: flags |= MSVCRT__PC_64; break;
1051         }
1052         if (fpword & 0x1000) flags |= MSVCRT__IC_AFFINE;
1053
1054         TRACE( "x86 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1055         if (mask)
1056         {
1057             flags = (flags & ~mask) | (newval & mask);
1058
1059             /* Convert (masked) value back to fp word */
1060             fpword = 0;
1061             if (flags & MSVCRT__EM_INVALID)    fpword |= 0x1;
1062             if (flags & MSVCRT__EM_DENORMAL)   fpword |= 0x2;
1063             if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x4;
1064             if (flags & MSVCRT__EM_OVERFLOW)   fpword |= 0x8;
1065             if (flags & MSVCRT__EM_UNDERFLOW)  fpword |= 0x10;
1066             if (flags & MSVCRT__EM_INEXACT)    fpword |= 0x20;
1067             switch (flags & MSVCRT__MCW_RC)
1068             {
1069             case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0xc00; break;
1070             case MSVCRT__RC_UP:                 fpword |= 0x800; break;
1071             case MSVCRT__RC_DOWN:               fpword |= 0x400; break;
1072             }
1073             switch (flags & MSVCRT__MCW_PC)
1074             {
1075             case MSVCRT__PC_64: fpword |= 0x300; break;
1076             case MSVCRT__PC_53: fpword |= 0x200; break;
1077             case MSVCRT__PC_24: fpword |= 0x0; break;
1078             }
1079             if (flags & MSVCRT__IC_AFFINE) fpword |= 0x1000;
1080
1081             __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
1082         }
1083         *x86_cw = flags;
1084     }
1085
1086     if (!sse2_cw) return 1;
1087
1088     if (sse2_supported)
1089     {
1090         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
1091
1092         /* Convert into mask constants */
1093         flags = 0;
1094         if (fpword & 0x80)   flags |= MSVCRT__EM_INVALID;
1095         if (fpword & 0x100)  flags |= MSVCRT__EM_DENORMAL;
1096         if (fpword & 0x200)  flags |= MSVCRT__EM_ZERODIVIDE;
1097         if (fpword & 0x400)  flags |= MSVCRT__EM_OVERFLOW;
1098         if (fpword & 0x800)  flags |= MSVCRT__EM_UNDERFLOW;
1099         if (fpword & 0x1000) flags |= MSVCRT__EM_INEXACT;
1100         switch (fpword & 0x6000)
1101         {
1102         case 0x6000: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1103         case 0x4000: flags |= MSVCRT__RC_UP; break;
1104         case 0x2000: flags |= MSVCRT__RC_DOWN; break;
1105         }
1106         switch (fpword & 0x8040)
1107         {
1108         case 0x0040: flags |= MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS; break;
1109         case 0x8000: flags |= MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS; break;
1110         case 0x8040: flags |= MSVCRT__DN_FLUSH; break;
1111         }
1112
1113         TRACE( "sse2 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1114         if (mask)
1115         {
1116             flags = (flags & ~mask) | (newval & mask);
1117
1118             /* Convert (masked) value back to fp word */
1119             fpword = 0;
1120             if (flags & MSVCRT__EM_INVALID)    fpword |= 0x80;
1121             if (flags & MSVCRT__EM_DENORMAL)   fpword |= 0x100;
1122             if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x200;
1123             if (flags & MSVCRT__EM_OVERFLOW)   fpword |= 0x400;
1124             if (flags & MSVCRT__EM_UNDERFLOW)  fpword |= 0x800;
1125             if (flags & MSVCRT__EM_INEXACT)    fpword |= 0x1000;
1126             switch (flags & MSVCRT__MCW_RC)
1127             {
1128             case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0x6000; break;
1129             case MSVCRT__RC_UP:                 fpword |= 0x4000; break;
1130             case MSVCRT__RC_DOWN:               fpword |= 0x2000; break;
1131             }
1132             switch (flags & MSVCRT__MCW_DN)
1133             {
1134             case MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS: fpword |= 0x0040; break;
1135             case MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS: fpword |= 0x8000; break;
1136             case MSVCRT__DN_FLUSH:                       fpword |= 0x8040; break;
1137             }
1138             __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
1139         }
1140         *sse2_cw = flags;
1141     }
1142     else *sse2_cw = 0;
1143
1144     return 1;
1145 #else
1146     FIXME( "not implemented\n" );
1147     return 0;
1148 #endif
1149 }
1150 #endif
1151
1152 /*********************************************************************
1153  *              _control87 (MSVCRT.@)
1154  */
1155 unsigned int CDECL _control87(unsigned int newval, unsigned int mask)
1156 {
1157 #if defined(__i386__) || defined(__x86_64__)
1158     unsigned int x86_cw, sse2_cw;
1159
1160     __control87_2( newval, mask, &x86_cw, &sse2_cw );
1161
1162     if ((x86_cw ^ sse2_cw) & (MSVCRT__MCW_EM | MSVCRT__MCW_RC)) x86_cw |= MSVCRT__EM_AMBIGUOUS;
1163     return x86_cw;
1164 #else
1165     FIXME( "not implemented\n" );
1166     return 0;
1167 #endif
1168 }
1169
1170 /*********************************************************************
1171  *              _controlfp (MSVCRT.@)
1172  */
1173 unsigned int CDECL _controlfp(unsigned int newval, unsigned int mask)
1174 {
1175   return _control87( newval, mask & ~MSVCRT__EM_DENORMAL );
1176 }
1177
1178 /*********************************************************************
1179  *              _set_controlfp (MSVCRT.@)
1180  */
1181 void CDECL _set_controlfp( unsigned int newval, unsigned int mask )
1182 {
1183     _controlfp( newval, mask );
1184 }
1185
1186 /*********************************************************************
1187  *              _controlfp_s (MSVCRT.@)
1188  */
1189 int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
1190 {
1191     static const unsigned int all_flags = (MSVCRT__MCW_EM | MSVCRT__MCW_IC | MSVCRT__MCW_RC |
1192                                            MSVCRT__MCW_PC | MSVCRT__MCW_DN);
1193     unsigned int val;
1194
1195     if (!MSVCRT_CHECK_PMT( !(newval & mask & ~all_flags) ))
1196     {
1197         if (cur) *cur = _controlfp( 0, 0 );  /* retrieve it anyway */
1198         return MSVCRT_EINVAL;
1199     }
1200     val = _controlfp( newval, mask );
1201     if (cur) *cur = val;
1202     return 0;
1203 }
1204
1205 /*********************************************************************
1206  *              _copysign (MSVCRT.@)
1207  */
1208 double CDECL MSVCRT__copysign(double num, double sign)
1209 {
1210   /* FIXME: Behaviour for Nan/Inf? */
1211   if (sign < 0.0)
1212     return num < 0.0 ? num : -num;
1213   return num < 0.0 ? -num : num;
1214 }
1215
1216 /*********************************************************************
1217  *              _finite (MSVCRT.@)
1218  */
1219 int CDECL MSVCRT__finite(double num)
1220 {
1221   return (finite(num)?1:0); /* See comment for _isnan() */
1222 }
1223
1224 /*********************************************************************
1225  *              _fpreset (MSVCRT.@)
1226  */
1227 void CDECL _fpreset(void)
1228 {
1229 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1230     const unsigned int x86_cw = 0x27f;
1231     __asm__ __volatile__( "fninit; fldcw %0" : : "m" (x86_cw) );
1232     if (sse2_supported)
1233     {
1234         const unsigned long sse2_cw = 0x1f80;
1235         __asm__ __volatile__( "ldmxcsr %0" : : "m" (sse2_cw) );
1236     }
1237 #else
1238     FIXME( "not implemented\n" );
1239 #endif
1240 }
1241
1242 /*********************************************************************
1243  *              _isnan (MSVCRT.@)
1244  */
1245 INT CDECL MSVCRT__isnan(double num)
1246 {
1247   /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
1248    * Do the same, as the result may be used in calculations
1249    */
1250   return isnan(num) ? 1 : 0;
1251 }
1252
1253 /*********************************************************************
1254  *              _j0 (MSVCRT.@)
1255  */
1256 double CDECL MSVCRT__j0(double num)
1257 {
1258   /* FIXME: errno handling */
1259   return j0(num);
1260 }
1261
1262 /*********************************************************************
1263  *              _j1 (MSVCRT.@)
1264  */
1265 double CDECL MSVCRT__j1(double num)
1266 {
1267   /* FIXME: errno handling */
1268   return j1(num);
1269 }
1270
1271 /*********************************************************************
1272  *              _jn (MSVCRT.@)
1273  */
1274 double CDECL MSVCRT__jn(int n, double num)
1275 {
1276   /* FIXME: errno handling */
1277   return jn(n, num);
1278 }
1279
1280 /*********************************************************************
1281  *              _y0 (MSVCRT.@)
1282  */
1283 double CDECL MSVCRT__y0(double num)
1284 {
1285   double retval;
1286   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1287   retval  = y0(num);
1288   if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1289   {
1290     *MSVCRT__errno() = MSVCRT_EDOM;
1291     retval = sqrt(-1);
1292   }
1293   return retval;
1294 }
1295
1296 /*********************************************************************
1297  *              _y1 (MSVCRT.@)
1298  */
1299 double CDECL MSVCRT__y1(double num)
1300 {
1301   double retval;
1302   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1303   retval  = y1(num);
1304   if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1305   {
1306     *MSVCRT__errno() = MSVCRT_EDOM;
1307     retval = sqrt(-1);
1308   }
1309   return retval;
1310 }
1311
1312 /*********************************************************************
1313  *              _yn (MSVCRT.@)
1314  */
1315 double CDECL MSVCRT__yn(int order, double num)
1316 {
1317   double retval;
1318   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1319   retval  = yn(order,num);
1320   if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1321   {
1322     *MSVCRT__errno() = MSVCRT_EDOM;
1323     retval = sqrt(-1);
1324   }
1325   return retval;
1326 }
1327
1328 /*********************************************************************
1329  *              _nextafter (MSVCRT.@)
1330  */
1331 double CDECL MSVCRT__nextafter(double num, double next)
1332 {
1333   double retval;
1334   if (!finite(num) || !finite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
1335   retval = nextafter(num,next);
1336   return retval;
1337 }
1338
1339 /*********************************************************************
1340  *              _ecvt (MSVCRT.@)
1341  */
1342 char * CDECL _ecvt( double number, int ndigits, int *decpt, int *sign )
1343 {
1344     int prec, len;
1345     thread_data_t *data = msvcrt_get_thread_data();
1346     /* FIXME: check better for overflow (native supports over 300 chars) */
1347     ndigits = min( ndigits, 80 - 7); /* 7 : space for dec point, 1 for "e",
1348                                       * 4 for exponent and one for
1349                                       * terminating '\0' */
1350     if (!data->efcvt_buffer)
1351         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1352
1353     if( number < 0) {
1354         *sign = TRUE;
1355         number = -number;
1356     } else
1357         *sign = FALSE;
1358     /* handle cases with zero ndigits or less */
1359     prec = ndigits;
1360     if( prec < 1) prec = 2;
1361     len = snprintf(data->efcvt_buffer, 80, "%.*le", prec - 1, number);
1362     /* take the decimal "point away */
1363     if( prec != 1)
1364         memmove( data->efcvt_buffer + 1, data->efcvt_buffer + 2, len - 1 );
1365     /* take the exponential "e" out */
1366     data->efcvt_buffer[ prec] = '\0';
1367     /* read the exponent */
1368     sscanf( data->efcvt_buffer + prec + 1, "%d", decpt);
1369     (*decpt)++;
1370     /* adjust for some border cases */
1371     if( data->efcvt_buffer[0] == '0')/* value is zero */
1372         *decpt = 0;
1373     /* handle cases with zero ndigits or less */
1374     if( ndigits < 1){
1375         if( data->efcvt_buffer[ 0] >= '5')
1376             (*decpt)++;
1377         data->efcvt_buffer[ 0] = '\0';
1378     }
1379     TRACE("out=\"%s\"\n",data->efcvt_buffer);
1380     return data->efcvt_buffer;
1381 }
1382
1383 /*********************************************************************
1384  *              _ecvt_s (MSVCRT.@)
1385  */
1386 int CDECL _ecvt_s( char *buffer, MSVCRT_size_t length, double number, int ndigits, int *decpt, int *sign )
1387 {
1388     int prec, len;
1389     char *result;
1390     const char infret[] = "1#INF";
1391
1392     if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
1393     if (!MSVCRT_CHECK_PMT(decpt != NULL)) return MSVCRT_EINVAL;
1394     if (!MSVCRT_CHECK_PMT(sign != NULL)) return MSVCRT_EINVAL;
1395     if (!MSVCRT_CHECK_PMT_ERR( length > 2, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1396     if (!MSVCRT_CHECK_PMT_ERR(ndigits < (int)length - 1, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1397
1398     /* special case - inf */
1399     if(number == HUGE_VAL || number == -HUGE_VAL)
1400     {
1401         memset(buffer, '0', ndigits);
1402         memcpy(buffer, infret, min(ndigits, sizeof(infret) - 1 ) );
1403         buffer[ndigits] = '\0';
1404         (*decpt) = 1;
1405         if(number == -HUGE_VAL)
1406             (*sign) = 1;
1407         else
1408             (*sign) = 0;
1409         return 0;
1410     }
1411     /* handle cases with zero ndigits or less */
1412     prec = ndigits;
1413     if( prec < 1) prec = 2;
1414     result = MSVCRT_malloc(prec + 7);
1415
1416     if( number < 0) {
1417         *sign = TRUE;
1418         number = -number;
1419     } else
1420         *sign = FALSE;
1421     len = snprintf(result, prec + 7, "%.*le", prec - 1, number);
1422     /* take the decimal "point away */
1423     if( prec != 1)
1424         memmove( result + 1, result + 2, len - 1 );
1425     /* take the exponential "e" out */
1426     result[ prec] = '\0';
1427     /* read the exponent */
1428     sscanf( result + prec + 1, "%d", decpt);
1429     (*decpt)++;
1430     /* adjust for some border cases */
1431     if( result[0] == '0')/* value is zero */
1432         *decpt = 0;
1433     /* handle cases with zero ndigits or less */
1434     if( ndigits < 1){
1435         if( result[ 0] >= '5')
1436             (*decpt)++;
1437         result[ 0] = '\0';
1438     }
1439     memcpy( buffer, result, max(ndigits + 1, 1) );
1440     MSVCRT_free( result );
1441     return 0;
1442 }
1443
1444 /***********************************************************************
1445  *              _fcvt  (MSVCRT.@)
1446  */
1447 char * CDECL _fcvt( double number, int ndigits, int *decpt, int *sign )
1448 {
1449     thread_data_t *data = msvcrt_get_thread_data();
1450     int stop, dec1, dec2;
1451     char *ptr1, *ptr2, *first;
1452     char buf[80]; /* ought to be enough */
1453
1454     if (!data->efcvt_buffer)
1455         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1456
1457     if (number < 0)
1458     {
1459         *sign = 1;
1460         number = -number;
1461     } else *sign = 0;
1462
1463     snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1464     ptr1 = buf;
1465     ptr2 = data->efcvt_buffer;
1466     first = NULL;
1467     dec1 = 0;
1468     dec2 = 0;
1469
1470     /* For numbers below the requested resolution, work out where
1471        the decimal point will be rather than finding it in the string */
1472     if (number < 1.0 && number > 0.0) {
1473         dec2 = log10(number + 1e-10);
1474         if (-dec2 <= ndigits) dec2 = 0;
1475     }
1476
1477     /* If requested digits is zero or less, we will need to truncate
1478      * the returned string */
1479     if (ndigits < 1) {
1480         stop = strlen(buf) + ndigits;
1481     } else {
1482         stop = strlen(buf);
1483     }
1484
1485     while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1486     while (*ptr1 != '\0' && *ptr1 != '.') {
1487         if (!first) first = ptr2;
1488         if ((ptr1 - buf) < stop) {
1489             *ptr2++ = *ptr1++;
1490         } else {
1491             ptr1++;
1492         }
1493         dec1++;
1494     }
1495
1496     if (ndigits > 0) {
1497         ptr1++;
1498         if (!first) {
1499             while (*ptr1 == '0') { /* Process leading zeroes */
1500                 *ptr2++ = *ptr1++;
1501                 dec1--;
1502             }
1503         }
1504         while (*ptr1 != '\0') {
1505             if (!first) first = ptr2;
1506             *ptr2++ = *ptr1++;
1507         }
1508     }
1509
1510     *ptr2 = '\0';
1511
1512     /* We never found a non-zero digit, then our number is either
1513      * smaller than the requested precision, or 0.0 */
1514     if (!first) {
1515         if (number > 0.0) {
1516             first = ptr2;
1517         } else {
1518             first = data->efcvt_buffer;
1519             dec1 = 0;
1520         }
1521     }
1522
1523     *decpt = dec2 ? dec2 : dec1;
1524     return first;
1525 }
1526
1527 /***********************************************************************
1528  *              _fcvt_s  (MSVCRT.@)
1529  */
1530 int CDECL _fcvt_s(char* outbuffer, MSVCRT_size_t size, double number, int ndigits, int *decpt, int *sign)
1531 {
1532     int stop, dec1, dec2;
1533     char *ptr1, *ptr2, *first;
1534     char buf[80]; /* ought to be enough */
1535
1536     if (!outbuffer || !decpt || !sign || size == 0)
1537     {
1538         *MSVCRT__errno() = MSVCRT_EINVAL;
1539         return MSVCRT_EINVAL;
1540     }
1541
1542     if (number < 0)
1543     {
1544         *sign = 1;
1545         number = -number;
1546     } else *sign = 0;
1547
1548     snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1549     ptr1 = buf;
1550     ptr2 = outbuffer;
1551     first = NULL;
1552     dec1 = 0;
1553     dec2 = 0;
1554
1555     /* For numbers below the requested resolution, work out where
1556        the decimal point will be rather than finding it in the string */
1557     if (number < 1.0 && number > 0.0) {
1558         dec2 = log10(number + 1e-10);
1559         if (-dec2 <= ndigits) dec2 = 0;
1560     }
1561
1562     /* If requested digits is zero or less, we will need to truncate
1563      * the returned string */
1564     if (ndigits < 1) {
1565         stop = strlen(buf) + ndigits;
1566     } else {
1567         stop = strlen(buf);
1568     }
1569
1570     while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1571     while (*ptr1 != '\0' && *ptr1 != '.') {
1572         if (!first) first = ptr2;
1573         if ((ptr1 - buf) < stop) {
1574             if (size > 1) {
1575                 *ptr2++ = *ptr1++;
1576                 size--;
1577             }
1578         } else {
1579             ptr1++;
1580         }
1581         dec1++;
1582     }
1583
1584     if (ndigits > 0) {
1585         ptr1++;
1586         if (!first) {
1587             while (*ptr1 == '0') { /* Process leading zeroes */
1588                 if (number == 0.0 && size > 1) {
1589                     *ptr2++ = '0';
1590                     size--;
1591                 }
1592                 ptr1++;
1593                 dec1--;
1594             }
1595         }
1596         while (*ptr1 != '\0') {
1597             if (!first) first = ptr2;
1598             if (size > 1) {
1599                 *ptr2++ = *ptr1++;
1600                 size--;
1601             }
1602         }
1603     }
1604
1605     *ptr2 = '\0';
1606
1607     /* We never found a non-zero digit, then our number is either
1608      * smaller than the requested precision, or 0.0 */
1609     if (!first && (number <= 0.0))
1610         dec1 = 0;
1611
1612     *decpt = dec2 ? dec2 : dec1;
1613     return 0;
1614 }
1615
1616 /***********************************************************************
1617  *              _gcvt  (MSVCRT.@)
1618  */
1619 char * CDECL _gcvt( double number, int ndigit, char *buff )
1620 {
1621     if(!buff) {
1622         *MSVCRT__errno() = MSVCRT_EINVAL;
1623         return NULL;
1624     }
1625
1626     if(ndigit < 0) {
1627         *MSVCRT__errno() = MSVCRT_ERANGE;
1628         return NULL;
1629     }
1630
1631     MSVCRT_sprintf(buff, "%.*g", ndigit, number);
1632     return buff;
1633 }
1634
1635 /***********************************************************************
1636  *              _gcvt_s  (MSVCRT.@)
1637  */
1638 int CDECL _gcvt_s(char *buff, MSVCRT_size_t size, double number, int digits)
1639 {
1640     int len;
1641
1642     if(!buff) {
1643         *MSVCRT__errno() = MSVCRT_EINVAL;
1644         return MSVCRT_EINVAL;
1645     }
1646
1647     if( digits<0 || digits>=size) {
1648         if(size)
1649             buff[0] = '\0';
1650
1651         *MSVCRT__errno() = MSVCRT_ERANGE;
1652         return MSVCRT_ERANGE;
1653     }
1654
1655     len = MSVCRT__scprintf("%.*g", digits, number);
1656     if(len > size) {
1657         buff[0] = '\0';
1658         *MSVCRT__errno() = MSVCRT_ERANGE;
1659         return MSVCRT_ERANGE;
1660     }
1661
1662     MSVCRT_sprintf(buff, "%.*g", digits, number);
1663     return 0;
1664 }
1665
1666 #include <stdlib.h> /* div_t, ldiv_t */
1667
1668 /*********************************************************************
1669  *              div (MSVCRT.@)
1670  * VERSION
1671  *      [i386] Windows binary compatible - returns the struct in eax/edx.
1672  */
1673 #ifdef __i386__
1674 unsigned __int64 CDECL MSVCRT_div(int num, int denom)
1675 {
1676   div_t dt = div(num,denom);
1677   return ((unsigned __int64)dt.rem << 32) | (unsigned int)dt.quot;
1678 }
1679 #else
1680 /*********************************************************************
1681  *              div (MSVCRT.@)
1682  * VERSION
1683  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1684  */
1685 MSVCRT_div_t CDECL MSVCRT_div(int num, int denom)
1686 {
1687   div_t dt = div(num,denom);
1688   MSVCRT_div_t     ret;
1689   ret.quot = dt.quot;
1690   ret.rem = dt.rem;
1691
1692   return ret;
1693
1694 }
1695 #endif /* ifdef __i386__ */
1696
1697
1698 /*********************************************************************
1699  *              ldiv (MSVCRT.@)
1700  * VERSION
1701  *      [i386] Windows binary compatible - returns the struct in eax/edx.
1702  */
1703 #ifdef __i386__
1704 unsigned __int64 CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1705 {
1706   ldiv_t ldt = ldiv(num,denom);
1707   return ((unsigned __int64)ldt.rem << 32) | (MSVCRT_ulong)ldt.quot;
1708 }
1709 #else
1710 /*********************************************************************
1711  *              ldiv (MSVCRT.@)
1712  * VERSION
1713  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1714  */
1715 MSVCRT_ldiv_t CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1716 {
1717   ldiv_t result = ldiv(num,denom);
1718
1719   MSVCRT_ldiv_t ret;
1720   ret.quot = result.quot;
1721   ret.rem = result.rem;
1722
1723   return ret;
1724 }
1725 #endif /* ifdef __i386__ */
1726
1727 #ifdef __i386__
1728
1729 /*********************************************************************
1730  *              _adjust_fdiv (MSVCRT.@)
1731  * Used by the MSVC compiler to work around the Pentium FDIV bug.
1732  */
1733 int MSVCRT__adjust_fdiv = 0;
1734
1735 /***********************************************************************
1736  *              _adj_fdiv_m16i (MSVCRT.@)
1737  *
1738  * NOTE
1739  *    I _think_ this function is intended to work around the Pentium
1740  *    fdiv bug.
1741  */
1742 void __stdcall _adj_fdiv_m16i( short arg )
1743 {
1744   TRACE("(): stub\n");
1745 }
1746
1747 /***********************************************************************
1748  *              _adj_fdiv_m32 (MSVCRT.@)
1749  *
1750  * NOTE
1751  *    I _think_ this function is intended to work around the Pentium
1752  *    fdiv bug.
1753  */
1754 void __stdcall _adj_fdiv_m32( unsigned int arg )
1755 {
1756   TRACE("(): stub\n");
1757 }
1758
1759 /***********************************************************************
1760  *              _adj_fdiv_m32i (MSVCRT.@)
1761  *
1762  * NOTE
1763  *    I _think_ this function is intended to work around the Pentium
1764  *    fdiv bug.
1765  */
1766 void __stdcall _adj_fdiv_m32i( int arg )
1767 {
1768   TRACE("(): stub\n");
1769 }
1770
1771 /***********************************************************************
1772  *              _adj_fdiv_m64 (MSVCRT.@)
1773  *
1774  * NOTE
1775  *    I _think_ this function is intended to work around the Pentium
1776  *    fdiv bug.
1777  */
1778 void __stdcall _adj_fdiv_m64( unsigned __int64 arg )
1779 {
1780   TRACE("(): stub\n");
1781 }
1782
1783 /***********************************************************************
1784  *              _adj_fdiv_r (MSVCRT.@)
1785  * FIXME
1786  *    This function is likely to have the wrong number of arguments.
1787  *
1788  * NOTE
1789  *    I _think_ this function is intended to work around the Pentium
1790  *    fdiv bug.
1791  */
1792 void _adj_fdiv_r(void)
1793 {
1794   TRACE("(): stub\n");
1795 }
1796
1797 /***********************************************************************
1798  *              _adj_fdivr_m16i (MSVCRT.@)
1799  *
1800  * NOTE
1801  *    I _think_ this function is intended to work around the Pentium
1802  *    fdiv bug.
1803  */
1804 void __stdcall _adj_fdivr_m16i( short arg )
1805 {
1806   TRACE("(): stub\n");
1807 }
1808
1809 /***********************************************************************
1810  *              _adj_fdivr_m32 (MSVCRT.@)
1811  *
1812  * NOTE
1813  *    I _think_ this function is intended to work around the Pentium
1814  *    fdiv bug.
1815  */
1816 void __stdcall _adj_fdivr_m32( unsigned int arg )
1817 {
1818   TRACE("(): stub\n");
1819 }
1820
1821 /***********************************************************************
1822  *              _adj_fdivr_m32i (MSVCRT.@)
1823  *
1824  * NOTE
1825  *    I _think_ this function is intended to work around the Pentium
1826  *    fdiv bug.
1827  */
1828 void __stdcall _adj_fdivr_m32i( int arg )
1829 {
1830   TRACE("(): stub\n");
1831 }
1832
1833 /***********************************************************************
1834  *              _adj_fdivr_m64 (MSVCRT.@)
1835  *
1836  * NOTE
1837  *    I _think_ this function is intended to work around the Pentium
1838  *    fdiv bug.
1839  */
1840 void __stdcall _adj_fdivr_m64( unsigned __int64 arg )
1841 {
1842   TRACE("(): stub\n");
1843 }
1844
1845 /***********************************************************************
1846  *              _adj_fpatan (MSVCRT.@)
1847  * FIXME
1848  *    This function is likely to have the wrong number of arguments.
1849  *
1850  * NOTE
1851  *    I _think_ this function is intended to work around the Pentium
1852  *    fdiv bug.
1853  */
1854 void _adj_fpatan(void)
1855 {
1856   TRACE("(): stub\n");
1857 }
1858
1859 /***********************************************************************
1860  *              _adj_fprem (MSVCRT.@)
1861  * FIXME
1862  *    This function is likely to have the wrong number of arguments.
1863  *
1864  * NOTE
1865  *    I _think_ this function is intended to work around the Pentium
1866  *    fdiv bug.
1867  */
1868 void _adj_fprem(void)
1869 {
1870   TRACE("(): stub\n");
1871 }
1872
1873 /***********************************************************************
1874  *              _adj_fprem1 (MSVCRT.@)
1875  * FIXME
1876  *    This function is likely to have the wrong number of arguments.
1877  *
1878  * NOTE
1879  *    I _think_ this function is intended to work around the Pentium
1880  *    fdiv bug.
1881  */
1882 void _adj_fprem1(void)
1883 {
1884   TRACE("(): stub\n");
1885 }
1886
1887 /***********************************************************************
1888  *              _adj_fptan (MSVCRT.@)
1889  * FIXME
1890  *    This function is likely to have the wrong number of arguments.
1891  *
1892  * NOTE
1893  *    I _think_ this function is intended to work around the Pentium
1894  *    fdiv bug.
1895  */
1896 void _adj_fptan(void)
1897 {
1898   TRACE("(): stub\n");
1899 }
1900
1901 /***********************************************************************
1902  *              _safe_fdiv (MSVCRT.@)
1903  * FIXME
1904  *    This function is likely to have the wrong number of arguments.
1905  *
1906  * NOTE
1907  *    I _think_ this function is intended to work around the Pentium
1908  *    fdiv bug.
1909  */
1910 void _safe_fdiv(void)
1911 {
1912   TRACE("(): stub\n");
1913 }
1914
1915 /***********************************************************************
1916  *              _safe_fdivr (MSVCRT.@)
1917  * FIXME
1918  *    This function is likely to have the wrong number of arguments.
1919  *
1920  * NOTE
1921  *    I _think_ this function is intended to work around the Pentium
1922  *    fdiv bug.
1923  */
1924 void _safe_fdivr(void)
1925 {
1926   TRACE("(): stub\n");
1927 }
1928
1929 /***********************************************************************
1930  *              _safe_fprem (MSVCRT.@)
1931  * FIXME
1932  *    This function is likely to have the wrong number of arguments.
1933  *
1934  * NOTE
1935  *    I _think_ this function is intended to work around the Pentium
1936  *    fdiv bug.
1937  */
1938 void _safe_fprem(void)
1939 {
1940   TRACE("(): stub\n");
1941 }
1942
1943 /***********************************************************************
1944  *              _safe_fprem1 (MSVCRT.@)
1945  *
1946  * FIXME
1947  *    This function is likely to have the wrong number of arguments.
1948  *
1949  * NOTE
1950  *    I _think_ this function is intended to work around the Pentium
1951  *    fdiv bug.
1952  */
1953 void _safe_fprem1(void)
1954 {
1955   TRACE("(): stub\n");
1956 }
1957
1958 /***********************************************************************
1959  *              __libm_sse2_acos   (MSVCRT.@)
1960  */
1961 void __cdecl __libm_sse2_acos(void)
1962 {
1963     double d;
1964     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
1965     d = acos( d );
1966     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
1967 }
1968
1969 /***********************************************************************
1970  *              __libm_sse2_acosf   (MSVCRT.@)
1971  */
1972 void __cdecl __libm_sse2_acosf(void)
1973 {
1974     float f;
1975     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
1976     f = acosf( f );
1977     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
1978 }
1979
1980 /***********************************************************************
1981  *              __libm_sse2_asin   (MSVCRT.@)
1982  */
1983 void __cdecl __libm_sse2_asin(void)
1984 {
1985     double d;
1986     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
1987     d = asin( d );
1988     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
1989 }
1990
1991 /***********************************************************************
1992  *              __libm_sse2_asinf   (MSVCRT.@)
1993  */
1994 void __cdecl __libm_sse2_asinf(void)
1995 {
1996     float f;
1997     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
1998     f = asinf( f );
1999     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2000 }
2001
2002 /***********************************************************************
2003  *              __libm_sse2_atan   (MSVCRT.@)
2004  */
2005 void __cdecl __libm_sse2_atan(void)
2006 {
2007     double d;
2008     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2009     d = atan( d );
2010     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2011 }
2012
2013 /***********************************************************************
2014  *              __libm_sse2_atan2   (MSVCRT.@)
2015  */
2016 void __cdecl __libm_sse2_atan2(void)
2017 {
2018     double d1, d2;
2019     __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2020     d1 = atan2( d1, d2 );
2021     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2022 }
2023
2024 /***********************************************************************
2025  *              __libm_sse2_atanf   (MSVCRT.@)
2026  */
2027 void __cdecl __libm_sse2_atanf(void)
2028 {
2029     float f;
2030     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2031     f = atanf( f );
2032     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2033 }
2034
2035 /***********************************************************************
2036  *              __libm_sse2_cos   (MSVCRT.@)
2037  */
2038 void __cdecl __libm_sse2_cos(void)
2039 {
2040     double d;
2041     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2042     d = cos( d );
2043     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2044 }
2045
2046 /***********************************************************************
2047  *              __libm_sse2_cosf   (MSVCRT.@)
2048  */
2049 void __cdecl __libm_sse2_cosf(void)
2050 {
2051     float f;
2052     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2053     f = cosf( f );
2054     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2055 }
2056
2057 /***********************************************************************
2058  *              __libm_sse2_exp   (MSVCRT.@)
2059  */
2060 void __cdecl __libm_sse2_exp(void)
2061 {
2062     double d;
2063     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2064     d = exp( d );
2065     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2066 }
2067
2068 /***********************************************************************
2069  *              __libm_sse2_expf   (MSVCRT.@)
2070  */
2071 void __cdecl __libm_sse2_expf(void)
2072 {
2073     float f;
2074     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2075     f = expf( f );
2076     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2077 }
2078
2079 /***********************************************************************
2080  *              __libm_sse2_log   (MSVCRT.@)
2081  */
2082 void __cdecl __libm_sse2_log(void)
2083 {
2084     double d;
2085     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2086     d = log( d );
2087     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2088 }
2089
2090 /***********************************************************************
2091  *              __libm_sse2_log10   (MSVCRT.@)
2092  */
2093 void __cdecl __libm_sse2_log10(void)
2094 {
2095     double d;
2096     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2097     d = log10( d );
2098     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2099 }
2100
2101 /***********************************************************************
2102  *              __libm_sse2_log10f   (MSVCRT.@)
2103  */
2104 void __cdecl __libm_sse2_log10f(void)
2105 {
2106     float f;
2107     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2108     f = log10f( f );
2109     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2110 }
2111
2112 /***********************************************************************
2113  *              __libm_sse2_logf   (MSVCRT.@)
2114  */
2115 void __cdecl __libm_sse2_logf(void)
2116 {
2117     float f;
2118     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2119     f = logf( f );
2120     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2121 }
2122
2123 /***********************************************************************
2124  *              __libm_sse2_pow   (MSVCRT.@)
2125  */
2126 void __cdecl __libm_sse2_pow(void)
2127 {
2128     double d1, d2;
2129     __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2130     d1 = pow( d1, d2 );
2131     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2132 }
2133
2134 /***********************************************************************
2135  *              __libm_sse2_powf   (MSVCRT.@)
2136  */
2137 void __cdecl __libm_sse2_powf(void)
2138 {
2139     float f1, f2;
2140     __asm__ __volatile__( "movd %%xmm0,%0; movd %%xmm1,%1" : "=g" (f1), "=g" (f2) );
2141     f1 = powf( f1, f2 );
2142     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f1) );
2143 }
2144
2145 /***********************************************************************
2146  *              __libm_sse2_sin   (MSVCRT.@)
2147  */
2148 void __cdecl __libm_sse2_sin(void)
2149 {
2150     double d;
2151     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2152     d = sin( d );
2153     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2154 }
2155
2156 /***********************************************************************
2157  *              __libm_sse2_sinf   (MSVCRT.@)
2158  */
2159 void __cdecl __libm_sse2_sinf(void)
2160 {
2161     float f;
2162     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2163     f = sinf( f );
2164     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2165 }
2166
2167 /***********************************************************************
2168  *              __libm_sse2_tan   (MSVCRT.@)
2169  */
2170 void __cdecl __libm_sse2_tan(void)
2171 {
2172     double d;
2173     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2174     d = tan( d );
2175     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2176 }
2177
2178 /***********************************************************************
2179  *              __libm_sse2_tanf   (MSVCRT.@)
2180  */
2181 void __cdecl __libm_sse2_tanf(void)
2182 {
2183     float f;
2184     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2185     f = tanf( f );
2186     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2187 }
2188
2189 #endif  /* __i386__ */