msvcrt: Add a number of floating point functions for 64-bit.
[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 #endif /* defined(__GNUC__) && defined(__i386__) */
633
634 /*********************************************************************
635  *              _fpclass (MSVCRT.@)
636  */
637 int CDECL MSVCRT__fpclass(double num)
638 {
639 #if defined(HAVE_FPCLASS) || defined(fpclass)
640   switch (fpclass( num ))
641   {
642 #ifdef FP_SNAN
643   case FP_SNAN:  return MSVCRT__FPCLASS_SNAN;
644 #endif
645 #ifdef FP_QNAN
646   case FP_QNAN:  return MSVCRT__FPCLASS_QNAN;
647 #endif
648 #ifdef FP_NINF
649   case FP_NINF:  return MSVCRT__FPCLASS_NINF;
650 #endif
651 #ifdef FP_PINF
652   case FP_PINF:  return MSVCRT__FPCLASS_PINF;
653 #endif
654 #ifdef FP_NDENORM
655   case FP_NDENORM: return MSVCRT__FPCLASS_ND;
656 #endif
657 #ifdef FP_PDENORM
658   case FP_PDENORM: return MSVCRT__FPCLASS_PD;
659 #endif
660 #ifdef FP_NZERO
661   case FP_NZERO: return MSVCRT__FPCLASS_NZ;
662 #endif
663 #ifdef FP_PZERO
664   case FP_PZERO: return MSVCRT__FPCLASS_PZ;
665 #endif
666 #ifdef FP_NNORM
667   case FP_NNORM: return MSVCRT__FPCLASS_NN;
668 #endif
669 #ifdef FP_PNORM
670   case FP_PNORM: return MSVCRT__FPCLASS_PN;
671 #endif
672   default: return MSVCRT__FPCLASS_PN;
673   }
674 #elif defined (fpclassify)
675   switch (fpclassify( num ))
676   {
677   case FP_NAN: return MSVCRT__FPCLASS_QNAN;
678   case FP_INFINITE: return signbit(num) ? MSVCRT__FPCLASS_NINF : MSVCRT__FPCLASS_PINF;
679   case FP_SUBNORMAL: return signbit(num) ?MSVCRT__FPCLASS_ND : MSVCRT__FPCLASS_PD;
680   case FP_ZERO: return signbit(num) ? MSVCRT__FPCLASS_NZ : MSVCRT__FPCLASS_PZ;
681   }
682   return signbit(num) ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN;
683 #else
684   if (!finite(num))
685     return MSVCRT__FPCLASS_QNAN;
686   return num == 0.0 ? MSVCRT__FPCLASS_PZ : (num < 0 ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN);
687 #endif
688 }
689
690 /*********************************************************************
691  *              _rotl (MSVCRT.@)
692  */
693 unsigned int CDECL _rotl(unsigned int num, int shift)
694 {
695   shift &= 31;
696   return (num << shift) | (num >> (32-shift));
697 }
698
699 /*********************************************************************
700  *              _lrotl (MSVCRT.@)
701  */
702 MSVCRT_ulong CDECL MSVCRT__lrotl(MSVCRT_ulong num, int shift)
703 {
704   shift &= 0x1f;
705   return (num << shift) | (num >> (32-shift));
706 }
707
708 /*********************************************************************
709  *              _lrotr (MSVCRT.@)
710  */
711 MSVCRT_ulong CDECL MSVCRT__lrotr(MSVCRT_ulong num, int shift)
712 {
713   shift &= 0x1f;
714   return (num >> shift) | (num << (32-shift));
715 }
716
717 /*********************************************************************
718  *              _rotr (MSVCRT.@)
719  */
720 unsigned int CDECL _rotr(unsigned int num, int shift)
721 {
722     shift &= 0x1f;
723     return (num >> shift) | (num << (32-shift));
724 }
725
726 /*********************************************************************
727  *              _rotl64 (MSVCRT.@)
728  */
729 unsigned __int64 CDECL _rotl64(unsigned __int64 num, int shift)
730 {
731   shift &= 63;
732   return (num << shift) | (num >> (64-shift));
733 }
734
735 /*********************************************************************
736  *              _rotr64 (MSVCRT.@)
737  */
738 unsigned __int64 CDECL _rotr64(unsigned __int64 num, int shift)
739 {
740     shift &= 63;
741     return (num >> shift) | (num << (64-shift));
742 }
743
744 /*********************************************************************
745  *              abs (MSVCRT.@)
746  */
747 int CDECL MSVCRT_abs( int n )
748 {
749     return n >= 0 ? n : -n;
750 }
751
752 /*********************************************************************
753  *              labs (MSVCRT.@)
754  */
755 MSVCRT_long CDECL MSVCRT_labs( MSVCRT_long n )
756 {
757     return n >= 0 ? n : -n;
758 }
759
760 /*********************************************************************
761  *              _abs64 (MSVCRT.@)
762  */
763 __int64 CDECL _abs64( __int64 n )
764 {
765     return n >= 0 ? n : -n;
766 }
767
768 /*********************************************************************
769  *              _logb (MSVCRT.@)
770  */
771 double CDECL MSVCRT__logb(double num)
772 {
773   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
774   return logb(num);
775 }
776
777 /*********************************************************************
778  *              _scalb (MSVCRT.@)
779  */
780 double CDECL MSVCRT__scalb(double num, MSVCRT_long power)
781 {
782   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
783   return ldexp(num, power);
784 }
785
786 /*********************************************************************
787  *              _hypot (MSVCRT.@)
788  */
789 double CDECL _hypot(double x, double y)
790 {
791   /* FIXME: errno handling */
792   return hypot( x, y );
793 }
794
795 /*********************************************************************
796  *      _hypotf (MSVCRT.@)
797  */
798 float CDECL MSVCRT__hypotf(float x, float y)
799 {
800   /* FIXME: errno handling */
801   return hypotf( x, y );
802 }
803
804 /*********************************************************************
805  *              ceil (MSVCRT.@)
806  */
807 double CDECL MSVCRT_ceil( double x )
808 {
809   return ceil(x);
810 }
811
812 /*********************************************************************
813  *              floor (MSVCRT.@)
814  */
815 double CDECL MSVCRT_floor( double x )
816 {
817   return floor(x);
818 }
819
820 /*********************************************************************
821  *              fabs (MSVCRT.@)
822  */
823 double CDECL MSVCRT_fabs( double x )
824 {
825   return fabs(x);
826 }
827
828 /*********************************************************************
829  *              frexp (MSVCRT.@)
830  */
831 double CDECL MSVCRT_frexp( double x, int *exp )
832 {
833   return frexp( x, exp );
834 }
835
836 /*********************************************************************
837  *              modf (MSVCRT.@)
838  */
839 double CDECL MSVCRT_modf( double x, double *iptr )
840 {
841   return modf( x, iptr );
842 }
843
844 /*********************************************************************
845  *              _matherr (MSVCRT.@)
846  */
847 int CDECL MSVCRT__matherr(struct MSVCRT__exception *e)
848 {
849   if (e)
850     TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
851           e->retval);
852   else
853     TRACE("(null)\n");
854   if (MSVCRT_default_matherr_func)
855     return MSVCRT_default_matherr_func(e);
856   ERR(":Unhandled math error!\n");
857   return 0;
858 }
859
860 /*********************************************************************
861  *              __setusermatherr (MSVCRT.@)
862  */
863 void CDECL MSVCRT___setusermatherr(MSVCRT_matherr_func func)
864 {
865   MSVCRT_default_matherr_func = func;
866   TRACE(":new matherr handler %p\n", func);
867 }
868
869 /**********************************************************************
870  *              _statusfp2 (MSVCRT.@)
871  *
872  * Not exported by native msvcrt, added in msvcr80.
873  */
874 #if defined(__i386__) || defined(__x86_64__)
875 void CDECL _statusfp2( unsigned int *x86_sw, unsigned int *sse2_sw )
876 {
877 #ifdef __GNUC__
878     unsigned int flags;
879     unsigned long fpword;
880
881     if (x86_sw)
882     {
883         __asm__ __volatile__( "fstsw %0" : "=m" (fpword) );
884         flags = 0;
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;
891         *x86_sw = flags;
892     }
893
894     if (!sse2_sw) return;
895
896     if (sse2_supported)
897     {
898         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
899         flags = 0;
900         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
901         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
902         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
903         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
904         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
905         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
906         *sse2_sw = flags;
907     }
908     else *sse2_sw = 0;
909 #else
910     FIXME( "not implemented\n" );
911 #endif
912 }
913 #endif
914
915 /**********************************************************************
916  *              _statusfp (MSVCRT.@)
917  */
918 unsigned int CDECL _statusfp(void)
919 {
920 #if defined(__i386__) || defined(__x86_64__)
921     unsigned int x86_sw, sse2_sw;
922
923     _statusfp2( &x86_sw, &sse2_sw );
924     /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
925     return x86_sw | sse2_sw;
926 #else
927     FIXME( "not implemented\n" );
928     return 0;
929 #endif
930 }
931
932 /*********************************************************************
933  *              _clearfp (MSVCRT.@)
934  */
935 unsigned int CDECL _clearfp(void)
936 {
937     unsigned int flags = 0;
938 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
939     unsigned long fpword;
940
941     __asm__ __volatile__( "fnstsw %0; fnclex" : "=m" (fpword) );
942     if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
943     if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
944     if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
945     if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
946     if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
947     if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
948
949     if (sse2_supported)
950     {
951         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
952         if (fpword & 0x1)  flags |= MSVCRT__SW_INVALID;
953         if (fpword & 0x2)  flags |= MSVCRT__SW_DENORMAL;
954         if (fpword & 0x4)  flags |= MSVCRT__SW_ZERODIVIDE;
955         if (fpword & 0x8)  flags |= MSVCRT__SW_OVERFLOW;
956         if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
957         if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
958         fpword &= ~0x3f;
959         __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
960     }
961 #else
962     FIXME( "not implemented\n" );
963 #endif
964     return flags;
965 }
966
967 /*********************************************************************
968  *              __fpecode (MSVCRT.@)
969  */
970 int * CDECL __fpecode(void)
971 {
972     return &msvcrt_get_thread_data()->fpecode;
973 }
974
975 /*********************************************************************
976  *              ldexp (MSVCRT.@)
977  */
978 double CDECL MSVCRT_ldexp(double num, MSVCRT_long exp)
979 {
980   double z = ldexp(num,exp);
981
982   if (!finite(z))
983     *MSVCRT__errno() = MSVCRT_ERANGE;
984   else if (z == 0 && signbit(z))
985     z = 0.0; /* Convert -0 -> +0 */
986   return z;
987 }
988
989 /*********************************************************************
990  *              _cabs (MSVCRT.@)
991  */
992 double CDECL MSVCRT__cabs(struct MSVCRT__complex num)
993 {
994   return sqrt(num.x * num.x + num.y * num.y);
995 }
996
997 /*********************************************************************
998  *              _chgsign (MSVCRT.@)
999  */
1000 double CDECL MSVCRT__chgsign(double num)
1001 {
1002   /* FIXME: +-infinity,Nan not tested */
1003   return -num;
1004 }
1005
1006 /*********************************************************************
1007  *              __control87_2 (MSVCRT.@)
1008  *
1009  * Not exported by native msvcrt, added in msvcr80.
1010  */
1011 #if defined(__i386__) || defined(__x86_64__)
1012 int CDECL __control87_2( unsigned int newval, unsigned int mask,
1013                          unsigned int *x86_cw, unsigned int *sse2_cw )
1014 {
1015 #ifdef __GNUC__
1016     unsigned long fpword;
1017     unsigned int flags;
1018
1019     if (x86_cw)
1020     {
1021         __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
1022
1023         /* Convert into mask constants */
1024         flags = 0;
1025         if (fpword & 0x1)  flags |= MSVCRT__EM_INVALID;
1026         if (fpword & 0x2)  flags |= MSVCRT__EM_DENORMAL;
1027         if (fpword & 0x4)  flags |= MSVCRT__EM_ZERODIVIDE;
1028         if (fpword & 0x8)  flags |= MSVCRT__EM_OVERFLOW;
1029         if (fpword & 0x10) flags |= MSVCRT__EM_UNDERFLOW;
1030         if (fpword & 0x20) flags |= MSVCRT__EM_INEXACT;
1031         switch (fpword & 0xc00)
1032         {
1033         case 0xc00: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1034         case 0x800: flags |= MSVCRT__RC_UP; break;
1035         case 0x400: flags |= MSVCRT__RC_DOWN; break;
1036         }
1037         switch (fpword & 0x300)
1038         {
1039         case 0x0:   flags |= MSVCRT__PC_24; break;
1040         case 0x200: flags |= MSVCRT__PC_53; break;
1041         case 0x300: flags |= MSVCRT__PC_64; break;
1042         }
1043         if (fpword & 0x1000) flags |= MSVCRT__IC_AFFINE;
1044
1045         TRACE( "x86 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1046         if (mask)
1047         {
1048             flags = (flags & ~mask) | (newval & mask);
1049
1050             /* Convert (masked) value back to fp word */
1051             fpword = 0;
1052             if (flags & MSVCRT__EM_INVALID)    fpword |= 0x1;
1053             if (flags & MSVCRT__EM_DENORMAL)   fpword |= 0x2;
1054             if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x4;
1055             if (flags & MSVCRT__EM_OVERFLOW)   fpword |= 0x8;
1056             if (flags & MSVCRT__EM_UNDERFLOW)  fpword |= 0x10;
1057             if (flags & MSVCRT__EM_INEXACT)    fpword |= 0x20;
1058             switch (flags & MSVCRT__MCW_RC)
1059             {
1060             case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0xc00; break;
1061             case MSVCRT__RC_UP:                 fpword |= 0x800; break;
1062             case MSVCRT__RC_DOWN:               fpword |= 0x400; break;
1063             }
1064             switch (flags & MSVCRT__MCW_PC)
1065             {
1066             case MSVCRT__PC_64: fpword |= 0x300; break;
1067             case MSVCRT__PC_53: fpword |= 0x200; break;
1068             case MSVCRT__PC_24: fpword |= 0x0; break;
1069             }
1070             if (flags & MSVCRT__IC_AFFINE) fpword |= 0x1000;
1071
1072             __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
1073         }
1074         *x86_cw = flags;
1075     }
1076
1077     if (!sse2_cw) return 1;
1078
1079     if (sse2_supported)
1080     {
1081         __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
1082
1083         /* Convert into mask constants */
1084         flags = 0;
1085         if (fpword & 0x80)   flags |= MSVCRT__EM_INVALID;
1086         if (fpword & 0x100)  flags |= MSVCRT__EM_DENORMAL;
1087         if (fpword & 0x200)  flags |= MSVCRT__EM_ZERODIVIDE;
1088         if (fpword & 0x400)  flags |= MSVCRT__EM_OVERFLOW;
1089         if (fpword & 0x800)  flags |= MSVCRT__EM_UNDERFLOW;
1090         if (fpword & 0x1000) flags |= MSVCRT__EM_INEXACT;
1091         switch (fpword & 0x6000)
1092         {
1093         case 0x6000: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1094         case 0x4000: flags |= MSVCRT__RC_UP; break;
1095         case 0x2000: flags |= MSVCRT__RC_DOWN; break;
1096         }
1097         switch (fpword & 0x8040)
1098         {
1099         case 0x0040: flags |= MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS; break;
1100         case 0x8000: flags |= MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS; break;
1101         case 0x8040: flags |= MSVCRT__DN_FLUSH; break;
1102         }
1103
1104         TRACE( "sse2 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1105         if (mask)
1106         {
1107             flags = (flags & ~mask) | (newval & mask);
1108
1109             /* Convert (masked) value back to fp word */
1110             fpword = 0;
1111             if (flags & MSVCRT__EM_INVALID)    fpword |= 0x80;
1112             if (flags & MSVCRT__EM_DENORMAL)   fpword |= 0x100;
1113             if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x200;
1114             if (flags & MSVCRT__EM_OVERFLOW)   fpword |= 0x400;
1115             if (flags & MSVCRT__EM_UNDERFLOW)  fpword |= 0x800;
1116             if (flags & MSVCRT__EM_INEXACT)    fpword |= 0x1000;
1117             switch (flags & MSVCRT__MCW_RC)
1118             {
1119             case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0x6000; break;
1120             case MSVCRT__RC_UP:                 fpword |= 0x4000; break;
1121             case MSVCRT__RC_DOWN:               fpword |= 0x2000; break;
1122             }
1123             switch (flags & MSVCRT__MCW_DN)
1124             {
1125             case MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS: fpword |= 0x0040; break;
1126             case MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS: fpword |= 0x8000; break;
1127             case MSVCRT__DN_FLUSH:                       fpword |= 0x8040; break;
1128             }
1129             __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
1130         }
1131         *sse2_cw = flags;
1132     }
1133     else *sse2_cw = 0;
1134
1135     return 1;
1136 #else
1137     FIXME( "not implemented\n" );
1138     return 0;
1139 #endif
1140 }
1141 #endif
1142
1143 /*********************************************************************
1144  *              _control87 (MSVCRT.@)
1145  */
1146 unsigned int CDECL _control87(unsigned int newval, unsigned int mask)
1147 {
1148 #if defined(__i386__) || defined(__x86_64__)
1149     unsigned int x86_cw, sse2_cw;
1150
1151     __control87_2( newval, mask, &x86_cw, &sse2_cw );
1152
1153     if ((x86_cw ^ sse2_cw) & (MSVCRT__MCW_EM | MSVCRT__MCW_RC)) x86_cw |= MSVCRT__EM_AMBIGUOUS;
1154     return x86_cw;
1155 #else
1156     FIXME( "not implemented\n" );
1157     return 0;
1158 #endif
1159 }
1160
1161 /*********************************************************************
1162  *              _controlfp (MSVCRT.@)
1163  */
1164 unsigned int CDECL _controlfp(unsigned int newval, unsigned int mask)
1165 {
1166   return _control87( newval, mask & ~MSVCRT__EM_DENORMAL );
1167 }
1168
1169 /*********************************************************************
1170  *              _set_controlfp (MSVCRT.@)
1171  */
1172 void CDECL _set_controlfp( unsigned int newval, unsigned int mask )
1173 {
1174     _controlfp( newval, mask );
1175 }
1176
1177 /*********************************************************************
1178  *              _controlfp_s (MSVCRT.@)
1179  */
1180 int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
1181 {
1182     static const unsigned int all_flags = (MSVCRT__MCW_EM | MSVCRT__MCW_IC | MSVCRT__MCW_RC |
1183                                            MSVCRT__MCW_PC | MSVCRT__MCW_DN);
1184     unsigned int val;
1185
1186     if (!MSVCRT_CHECK_PMT( !(newval & mask & ~all_flags) ))
1187     {
1188         if (cur) *cur = _controlfp( 0, 0 );  /* retrieve it anyway */
1189         return MSVCRT_EINVAL;
1190     }
1191     val = _controlfp( newval, mask );
1192     if (cur) *cur = val;
1193     return 0;
1194 }
1195
1196 /*********************************************************************
1197  *              _copysign (MSVCRT.@)
1198  */
1199 double CDECL MSVCRT__copysign(double num, double sign)
1200 {
1201   /* FIXME: Behaviour for Nan/Inf? */
1202   if (sign < 0.0)
1203     return num < 0.0 ? num : -num;
1204   return num < 0.0 ? -num : num;
1205 }
1206
1207 /*********************************************************************
1208  *              _finite (MSVCRT.@)
1209  */
1210 int CDECL MSVCRT__finite(double num)
1211 {
1212   return (finite(num)?1:0); /* See comment for _isnan() */
1213 }
1214
1215 /*********************************************************************
1216  *              _fpreset (MSVCRT.@)
1217  */
1218 void CDECL _fpreset(void)
1219 {
1220 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1221     const unsigned int x86_cw = 0x27f;
1222     __asm__ __volatile__( "fninit; fldcw %0" : : "m" (x86_cw) );
1223     if (sse2_supported)
1224     {
1225         const unsigned long sse2_cw = 0x1f80;
1226         __asm__ __volatile__( "ldmxcsr %0" : : "m" (sse2_cw) );
1227     }
1228 #else
1229     FIXME( "not implemented\n" );
1230 #endif
1231 }
1232
1233 /*********************************************************************
1234  *              _isnan (MSVCRT.@)
1235  */
1236 INT CDECL MSVCRT__isnan(double num)
1237 {
1238   /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
1239    * Do the same, as the result may be used in calculations
1240    */
1241   return isnan(num) ? 1 : 0;
1242 }
1243
1244 /*********************************************************************
1245  *              _j0 (MSVCRT.@)
1246  */
1247 double CDECL MSVCRT__j0(double num)
1248 {
1249   /* FIXME: errno handling */
1250   return j0(num);
1251 }
1252
1253 /*********************************************************************
1254  *              _j1 (MSVCRT.@)
1255  */
1256 double CDECL MSVCRT__j1(double num)
1257 {
1258   /* FIXME: errno handling */
1259   return j1(num);
1260 }
1261
1262 /*********************************************************************
1263  *              _jn (MSVCRT.@)
1264  */
1265 double CDECL MSVCRT__jn(int n, double num)
1266 {
1267   /* FIXME: errno handling */
1268   return jn(n, num);
1269 }
1270
1271 /*********************************************************************
1272  *              _y0 (MSVCRT.@)
1273  */
1274 double CDECL MSVCRT__y0(double num)
1275 {
1276   double retval;
1277   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1278   retval  = y0(num);
1279   if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1280   {
1281     *MSVCRT__errno() = MSVCRT_EDOM;
1282     retval = sqrt(-1);
1283   }
1284   return retval;
1285 }
1286
1287 /*********************************************************************
1288  *              _y1 (MSVCRT.@)
1289  */
1290 double CDECL MSVCRT__y1(double num)
1291 {
1292   double retval;
1293   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1294   retval  = y1(num);
1295   if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1296   {
1297     *MSVCRT__errno() = MSVCRT_EDOM;
1298     retval = sqrt(-1);
1299   }
1300   return retval;
1301 }
1302
1303 /*********************************************************************
1304  *              _yn (MSVCRT.@)
1305  */
1306 double CDECL MSVCRT__yn(int order, double num)
1307 {
1308   double retval;
1309   if (!finite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1310   retval  = yn(order,num);
1311   if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1312   {
1313     *MSVCRT__errno() = MSVCRT_EDOM;
1314     retval = sqrt(-1);
1315   }
1316   return retval;
1317 }
1318
1319 /*********************************************************************
1320  *              _nextafter (MSVCRT.@)
1321  */
1322 double CDECL MSVCRT__nextafter(double num, double next)
1323 {
1324   double retval;
1325   if (!finite(num) || !finite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
1326   retval = nextafter(num,next);
1327   return retval;
1328 }
1329
1330 /*********************************************************************
1331  *              _ecvt (MSVCRT.@)
1332  */
1333 char * CDECL _ecvt( double number, int ndigits, int *decpt, int *sign )
1334 {
1335     int prec, len;
1336     thread_data_t *data = msvcrt_get_thread_data();
1337     /* FIXME: check better for overflow (native supports over 300 chars) */
1338     ndigits = min( ndigits, 80 - 7); /* 7 : space for dec point, 1 for "e",
1339                                       * 4 for exponent and one for
1340                                       * terminating '\0' */
1341     if (!data->efcvt_buffer)
1342         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1343
1344     if( number < 0) {
1345         *sign = TRUE;
1346         number = -number;
1347     } else
1348         *sign = FALSE;
1349     /* handle cases with zero ndigits or less */
1350     prec = ndigits;
1351     if( prec < 1) prec = 2;
1352     len = snprintf(data->efcvt_buffer, 80, "%.*le", prec - 1, number);
1353     /* take the decimal "point away */
1354     if( prec != 1)
1355         memmove( data->efcvt_buffer + 1, data->efcvt_buffer + 2, len - 1 );
1356     /* take the exponential "e" out */
1357     data->efcvt_buffer[ prec] = '\0';
1358     /* read the exponent */
1359     sscanf( data->efcvt_buffer + prec + 1, "%d", decpt);
1360     (*decpt)++;
1361     /* adjust for some border cases */
1362     if( data->efcvt_buffer[0] == '0')/* value is zero */
1363         *decpt = 0;
1364     /* handle cases with zero ndigits or less */
1365     if( ndigits < 1){
1366         if( data->efcvt_buffer[ 0] >= '5')
1367             (*decpt)++;
1368         data->efcvt_buffer[ 0] = '\0';
1369     }
1370     TRACE("out=\"%s\"\n",data->efcvt_buffer);
1371     return data->efcvt_buffer;
1372 }
1373
1374 /*********************************************************************
1375  *              _ecvt_s (MSVCRT.@)
1376  */
1377 int CDECL _ecvt_s( char *buffer, MSVCRT_size_t length, double number, int ndigits, int *decpt, int *sign )
1378 {
1379     int prec, len;
1380     char *result;
1381     const char infret[] = "1#INF";
1382
1383     if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
1384     if (!MSVCRT_CHECK_PMT(decpt != NULL)) return MSVCRT_EINVAL;
1385     if (!MSVCRT_CHECK_PMT(sign != NULL)) return MSVCRT_EINVAL;
1386     if (!MSVCRT_CHECK_PMT_ERR( length > 2, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1387     if (!MSVCRT_CHECK_PMT_ERR(ndigits < (int)length - 1, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1388
1389     /* special case - inf */
1390     if(number == HUGE_VAL || number == -HUGE_VAL)
1391     {
1392         memset(buffer, '0', ndigits);
1393         memcpy(buffer, infret, min(ndigits, sizeof(infret) - 1 ) );
1394         buffer[ndigits] = '\0';
1395         (*decpt) = 1;
1396         if(number == -HUGE_VAL)
1397             (*sign) = 1;
1398         else
1399             (*sign) = 0;
1400         return 0;
1401     }
1402     /* handle cases with zero ndigits or less */
1403     prec = ndigits;
1404     if( prec < 1) prec = 2;
1405     result = MSVCRT_malloc(prec + 7);
1406
1407     if( number < 0) {
1408         *sign = TRUE;
1409         number = -number;
1410     } else
1411         *sign = FALSE;
1412     len = snprintf(result, prec + 7, "%.*le", prec - 1, number);
1413     /* take the decimal "point away */
1414     if( prec != 1)
1415         memmove( result + 1, result + 2, len - 1 );
1416     /* take the exponential "e" out */
1417     result[ prec] = '\0';
1418     /* read the exponent */
1419     sscanf( result + prec + 1, "%d", decpt);
1420     (*decpt)++;
1421     /* adjust for some border cases */
1422     if( result[0] == '0')/* value is zero */
1423         *decpt = 0;
1424     /* handle cases with zero ndigits or less */
1425     if( ndigits < 1){
1426         if( result[ 0] >= '5')
1427             (*decpt)++;
1428         result[ 0] = '\0';
1429     }
1430     memcpy( buffer, result, max(ndigits + 1, 1) );
1431     MSVCRT_free( result );
1432     return 0;
1433 }
1434
1435 /***********************************************************************
1436  *              _fcvt  (MSVCRT.@)
1437  */
1438 char * CDECL _fcvt( double number, int ndigits, int *decpt, int *sign )
1439 {
1440     thread_data_t *data = msvcrt_get_thread_data();
1441     int stop, dec1, dec2;
1442     char *ptr1, *ptr2, *first;
1443     char buf[80]; /* ought to be enough */
1444
1445     if (!data->efcvt_buffer)
1446         data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1447
1448     if (number < 0)
1449     {
1450         *sign = 1;
1451         number = -number;
1452     } else *sign = 0;
1453
1454     snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1455     ptr1 = buf;
1456     ptr2 = data->efcvt_buffer;
1457     first = NULL;
1458     dec1 = 0;
1459     dec2 = 0;
1460
1461     /* For numbers below the requested resolution, work out where
1462        the decimal point will be rather than finding it in the string */
1463     if (number < 1.0 && number > 0.0) {
1464         dec2 = log10(number + 1e-10);
1465         if (-dec2 <= ndigits) dec2 = 0;
1466     }
1467
1468     /* If requested digits is zero or less, we will need to truncate
1469      * the returned string */
1470     if (ndigits < 1) {
1471         stop = strlen(buf) + ndigits;
1472     } else {
1473         stop = strlen(buf);
1474     }
1475
1476     while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1477     while (*ptr1 != '\0' && *ptr1 != '.') {
1478         if (!first) first = ptr2;
1479         if ((ptr1 - buf) < stop) {
1480             *ptr2++ = *ptr1++;
1481         } else {
1482             ptr1++;
1483         }
1484         dec1++;
1485     }
1486
1487     if (ndigits > 0) {
1488         ptr1++;
1489         if (!first) {
1490             while (*ptr1 == '0') { /* Process leading zeroes */
1491                 *ptr2++ = *ptr1++;
1492                 dec1--;
1493             }
1494         }
1495         while (*ptr1 != '\0') {
1496             if (!first) first = ptr2;
1497             *ptr2++ = *ptr1++;
1498         }
1499     }
1500
1501     *ptr2 = '\0';
1502
1503     /* We never found a non-zero digit, then our number is either
1504      * smaller than the requested precision, or 0.0 */
1505     if (!first) {
1506         if (number > 0.0) {
1507             first = ptr2;
1508         } else {
1509             first = data->efcvt_buffer;
1510             dec1 = 0;
1511         }
1512     }
1513
1514     *decpt = dec2 ? dec2 : dec1;
1515     return first;
1516 }
1517
1518 /***********************************************************************
1519  *              _fcvt_s  (MSVCRT.@)
1520  */
1521 int CDECL _fcvt_s(char* outbuffer, MSVCRT_size_t size, double number, int ndigits, int *decpt, int *sign)
1522 {
1523     int stop, dec1, dec2;
1524     char *ptr1, *ptr2, *first;
1525     char buf[80]; /* ought to be enough */
1526
1527     if (!outbuffer || !decpt || !sign || size == 0)
1528     {
1529         *MSVCRT__errno() = MSVCRT_EINVAL;
1530         return MSVCRT_EINVAL;
1531     }
1532
1533     if (number < 0)
1534     {
1535         *sign = 1;
1536         number = -number;
1537     } else *sign = 0;
1538
1539     snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1540     ptr1 = buf;
1541     ptr2 = outbuffer;
1542     first = NULL;
1543     dec1 = 0;
1544     dec2 = 0;
1545
1546     /* For numbers below the requested resolution, work out where
1547        the decimal point will be rather than finding it in the string */
1548     if (number < 1.0 && number > 0.0) {
1549         dec2 = log10(number + 1e-10);
1550         if (-dec2 <= ndigits) dec2 = 0;
1551     }
1552
1553     /* If requested digits is zero or less, we will need to truncate
1554      * the returned string */
1555     if (ndigits < 1) {
1556         stop = strlen(buf) + ndigits;
1557     } else {
1558         stop = strlen(buf);
1559     }
1560
1561     while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1562     while (*ptr1 != '\0' && *ptr1 != '.') {
1563         if (!first) first = ptr2;
1564         if ((ptr1 - buf) < stop) {
1565             if (size > 1) {
1566                 *ptr2++ = *ptr1++;
1567                 size--;
1568             }
1569         } else {
1570             ptr1++;
1571         }
1572         dec1++;
1573     }
1574
1575     if (ndigits > 0) {
1576         ptr1++;
1577         if (!first) {
1578             while (*ptr1 == '0') { /* Process leading zeroes */
1579                 if (number == 0.0 && size > 1) {
1580                     *ptr2++ = '0';
1581                     size--;
1582                 }
1583                 ptr1++;
1584                 dec1--;
1585             }
1586         }
1587         while (*ptr1 != '\0') {
1588             if (!first) first = ptr2;
1589             if (size > 1) {
1590                 *ptr2++ = *ptr1++;
1591                 size--;
1592             }
1593         }
1594     }
1595
1596     *ptr2 = '\0';
1597
1598     /* We never found a non-zero digit, then our number is either
1599      * smaller than the requested precision, or 0.0 */
1600     if (!first && (number <= 0.0))
1601         dec1 = 0;
1602
1603     *decpt = dec2 ? dec2 : dec1;
1604     return 0;
1605 }
1606
1607 /***********************************************************************
1608  *              _gcvt  (MSVCRT.@)
1609  */
1610 char * CDECL _gcvt( double number, int ndigit, char *buff )
1611 {
1612     if(!buff) {
1613         *MSVCRT__errno() = MSVCRT_EINVAL;
1614         return NULL;
1615     }
1616
1617     if(ndigit < 0) {
1618         *MSVCRT__errno() = MSVCRT_ERANGE;
1619         return NULL;
1620     }
1621
1622     MSVCRT_sprintf(buff, "%.*g", ndigit, number);
1623     return buff;
1624 }
1625
1626 /***********************************************************************
1627  *              _gcvt_s  (MSVCRT.@)
1628  */
1629 int CDECL _gcvt_s(char *buff, MSVCRT_size_t size, double number, int digits)
1630 {
1631     int len;
1632
1633     if(!buff) {
1634         *MSVCRT__errno() = MSVCRT_EINVAL;
1635         return MSVCRT_EINVAL;
1636     }
1637
1638     if( digits<0 || digits>=size) {
1639         if(size)
1640             buff[0] = '\0';
1641
1642         *MSVCRT__errno() = MSVCRT_ERANGE;
1643         return MSVCRT_ERANGE;
1644     }
1645
1646     len = MSVCRT__scprintf("%.*g", digits, number);
1647     if(len > size) {
1648         buff[0] = '\0';
1649         *MSVCRT__errno() = MSVCRT_ERANGE;
1650         return MSVCRT_ERANGE;
1651     }
1652
1653     MSVCRT_sprintf(buff, "%.*g", digits, number);
1654     return 0;
1655 }
1656
1657 #include <stdlib.h> /* div_t, ldiv_t */
1658
1659 /*********************************************************************
1660  *              div (MSVCRT.@)
1661  * VERSION
1662  *      [i386] Windows binary compatible - returns the struct in eax/edx.
1663  */
1664 #ifdef __i386__
1665 unsigned __int64 CDECL MSVCRT_div(int num, int denom)
1666 {
1667   div_t dt = div(num,denom);
1668   return ((unsigned __int64)dt.rem << 32) | (unsigned int)dt.quot;
1669 }
1670 #else
1671 /*********************************************************************
1672  *              div (MSVCRT.@)
1673  * VERSION
1674  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1675  */
1676 MSVCRT_div_t CDECL MSVCRT_div(int num, int denom)
1677 {
1678   div_t dt = div(num,denom);
1679   MSVCRT_div_t     ret;
1680   ret.quot = dt.quot;
1681   ret.rem = dt.rem;
1682
1683   return ret;
1684
1685 }
1686 #endif /* ifdef __i386__ */
1687
1688
1689 /*********************************************************************
1690  *              ldiv (MSVCRT.@)
1691  * VERSION
1692  *      [i386] Windows binary compatible - returns the struct in eax/edx.
1693  */
1694 #ifdef __i386__
1695 unsigned __int64 CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1696 {
1697   ldiv_t ldt = ldiv(num,denom);
1698   return ((unsigned __int64)ldt.rem << 32) | (MSVCRT_ulong)ldt.quot;
1699 }
1700 #else
1701 /*********************************************************************
1702  *              ldiv (MSVCRT.@)
1703  * VERSION
1704  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1705  */
1706 MSVCRT_ldiv_t CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1707 {
1708   ldiv_t result = ldiv(num,denom);
1709
1710   MSVCRT_ldiv_t ret;
1711   ret.quot = result.quot;
1712   ret.rem = result.rem;
1713
1714   return ret;
1715 }
1716 #endif /* ifdef __i386__ */
1717
1718 #ifdef __i386__
1719
1720 /*********************************************************************
1721  *              _adjust_fdiv (MSVCRT.@)
1722  * Used by the MSVC compiler to work around the Pentium FDIV bug.
1723  */
1724 int MSVCRT__adjust_fdiv = 0;
1725
1726 /***********************************************************************
1727  *              _adj_fdiv_m16i (MSVCRT.@)
1728  *
1729  * NOTE
1730  *    I _think_ this function is intended to work around the Pentium
1731  *    fdiv bug.
1732  */
1733 void __stdcall _adj_fdiv_m16i( short arg )
1734 {
1735   TRACE("(): stub\n");
1736 }
1737
1738 /***********************************************************************
1739  *              _adj_fdiv_m32 (MSVCRT.@)
1740  *
1741  * NOTE
1742  *    I _think_ this function is intended to work around the Pentium
1743  *    fdiv bug.
1744  */
1745 void __stdcall _adj_fdiv_m32( unsigned int arg )
1746 {
1747   TRACE("(): stub\n");
1748 }
1749
1750 /***********************************************************************
1751  *              _adj_fdiv_m32i (MSVCRT.@)
1752  *
1753  * NOTE
1754  *    I _think_ this function is intended to work around the Pentium
1755  *    fdiv bug.
1756  */
1757 void __stdcall _adj_fdiv_m32i( int arg )
1758 {
1759   TRACE("(): stub\n");
1760 }
1761
1762 /***********************************************************************
1763  *              _adj_fdiv_m64 (MSVCRT.@)
1764  *
1765  * NOTE
1766  *    I _think_ this function is intended to work around the Pentium
1767  *    fdiv bug.
1768  */
1769 void __stdcall _adj_fdiv_m64( unsigned __int64 arg )
1770 {
1771   TRACE("(): stub\n");
1772 }
1773
1774 /***********************************************************************
1775  *              _adj_fdiv_r (MSVCRT.@)
1776  * FIXME
1777  *    This function is likely to have the wrong number of arguments.
1778  *
1779  * NOTE
1780  *    I _think_ this function is intended to work around the Pentium
1781  *    fdiv bug.
1782  */
1783 void _adj_fdiv_r(void)
1784 {
1785   TRACE("(): stub\n");
1786 }
1787
1788 /***********************************************************************
1789  *              _adj_fdivr_m16i (MSVCRT.@)
1790  *
1791  * NOTE
1792  *    I _think_ this function is intended to work around the Pentium
1793  *    fdiv bug.
1794  */
1795 void __stdcall _adj_fdivr_m16i( short arg )
1796 {
1797   TRACE("(): stub\n");
1798 }
1799
1800 /***********************************************************************
1801  *              _adj_fdivr_m32 (MSVCRT.@)
1802  *
1803  * NOTE
1804  *    I _think_ this function is intended to work around the Pentium
1805  *    fdiv bug.
1806  */
1807 void __stdcall _adj_fdivr_m32( unsigned int arg )
1808 {
1809   TRACE("(): stub\n");
1810 }
1811
1812 /***********************************************************************
1813  *              _adj_fdivr_m32i (MSVCRT.@)
1814  *
1815  * NOTE
1816  *    I _think_ this function is intended to work around the Pentium
1817  *    fdiv bug.
1818  */
1819 void __stdcall _adj_fdivr_m32i( int arg )
1820 {
1821   TRACE("(): stub\n");
1822 }
1823
1824 /***********************************************************************
1825  *              _adj_fdivr_m64 (MSVCRT.@)
1826  *
1827  * NOTE
1828  *    I _think_ this function is intended to work around the Pentium
1829  *    fdiv bug.
1830  */
1831 void __stdcall _adj_fdivr_m64( unsigned __int64 arg )
1832 {
1833   TRACE("(): stub\n");
1834 }
1835
1836 /***********************************************************************
1837  *              _adj_fpatan (MSVCRT.@)
1838  * FIXME
1839  *    This function is likely to have the wrong number of arguments.
1840  *
1841  * NOTE
1842  *    I _think_ this function is intended to work around the Pentium
1843  *    fdiv bug.
1844  */
1845 void _adj_fpatan(void)
1846 {
1847   TRACE("(): stub\n");
1848 }
1849
1850 /***********************************************************************
1851  *              _adj_fprem (MSVCRT.@)
1852  * FIXME
1853  *    This function is likely to have the wrong number of arguments.
1854  *
1855  * NOTE
1856  *    I _think_ this function is intended to work around the Pentium
1857  *    fdiv bug.
1858  */
1859 void _adj_fprem(void)
1860 {
1861   TRACE("(): stub\n");
1862 }
1863
1864 /***********************************************************************
1865  *              _adj_fprem1 (MSVCRT.@)
1866  * FIXME
1867  *    This function is likely to have the wrong number of arguments.
1868  *
1869  * NOTE
1870  *    I _think_ this function is intended to work around the Pentium
1871  *    fdiv bug.
1872  */
1873 void _adj_fprem1(void)
1874 {
1875   TRACE("(): stub\n");
1876 }
1877
1878 /***********************************************************************
1879  *              _adj_fptan (MSVCRT.@)
1880  * FIXME
1881  *    This function is likely to have the wrong number of arguments.
1882  *
1883  * NOTE
1884  *    I _think_ this function is intended to work around the Pentium
1885  *    fdiv bug.
1886  */
1887 void _adj_fptan(void)
1888 {
1889   TRACE("(): stub\n");
1890 }
1891
1892 /***********************************************************************
1893  *              _safe_fdiv (MSVCRT.@)
1894  * FIXME
1895  *    This function is likely to have the wrong number of arguments.
1896  *
1897  * NOTE
1898  *    I _think_ this function is intended to work around the Pentium
1899  *    fdiv bug.
1900  */
1901 void _safe_fdiv(void)
1902 {
1903   TRACE("(): stub\n");
1904 }
1905
1906 /***********************************************************************
1907  *              _safe_fdivr (MSVCRT.@)
1908  * FIXME
1909  *    This function is likely to have the wrong number of arguments.
1910  *
1911  * NOTE
1912  *    I _think_ this function is intended to work around the Pentium
1913  *    fdiv bug.
1914  */
1915 void _safe_fdivr(void)
1916 {
1917   TRACE("(): stub\n");
1918 }
1919
1920 /***********************************************************************
1921  *              _safe_fprem (MSVCRT.@)
1922  * FIXME
1923  *    This function is likely to have the wrong number of arguments.
1924  *
1925  * NOTE
1926  *    I _think_ this function is intended to work around the Pentium
1927  *    fdiv bug.
1928  */
1929 void _safe_fprem(void)
1930 {
1931   TRACE("(): stub\n");
1932 }
1933
1934 /***********************************************************************
1935  *              _safe_fprem1 (MSVCRT.@)
1936  *
1937  * FIXME
1938  *    This function is likely to have the wrong number of arguments.
1939  *
1940  * NOTE
1941  *    I _think_ this function is intended to work around the Pentium
1942  *    fdiv bug.
1943  */
1944 void _safe_fprem1(void)
1945 {
1946   TRACE("(): stub\n");
1947 }
1948
1949 /***********************************************************************
1950  *              __libm_sse2_acos   (MSVCRT.@)
1951  */
1952 void __cdecl __libm_sse2_acos(void)
1953 {
1954     double d;
1955     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
1956     d = acos( d );
1957     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
1958 }
1959
1960 /***********************************************************************
1961  *              __libm_sse2_acosf   (MSVCRT.@)
1962  */
1963 void __cdecl __libm_sse2_acosf(void)
1964 {
1965     float f;
1966     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
1967     f = acosf( f );
1968     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
1969 }
1970
1971 /***********************************************************************
1972  *              __libm_sse2_asin   (MSVCRT.@)
1973  */
1974 void __cdecl __libm_sse2_asin(void)
1975 {
1976     double d;
1977     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
1978     d = asin( d );
1979     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
1980 }
1981
1982 /***********************************************************************
1983  *              __libm_sse2_asinf   (MSVCRT.@)
1984  */
1985 void __cdecl __libm_sse2_asinf(void)
1986 {
1987     float f;
1988     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
1989     f = asinf( f );
1990     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
1991 }
1992
1993 /***********************************************************************
1994  *              __libm_sse2_atan   (MSVCRT.@)
1995  */
1996 void __cdecl __libm_sse2_atan(void)
1997 {
1998     double d;
1999     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2000     d = atan( d );
2001     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2002 }
2003
2004 /***********************************************************************
2005  *              __libm_sse2_atan2   (MSVCRT.@)
2006  */
2007 void __cdecl __libm_sse2_atan2(void)
2008 {
2009     double d1, d2;
2010     __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2011     d1 = atan2( d1, d2 );
2012     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2013 }
2014
2015 /***********************************************************************
2016  *              __libm_sse2_atanf   (MSVCRT.@)
2017  */
2018 void __cdecl __libm_sse2_atanf(void)
2019 {
2020     float f;
2021     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2022     f = atanf( f );
2023     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2024 }
2025
2026 /***********************************************************************
2027  *              __libm_sse2_cos   (MSVCRT.@)
2028  */
2029 void __cdecl __libm_sse2_cos(void)
2030 {
2031     double d;
2032     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2033     d = cos( d );
2034     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2035 }
2036
2037 /***********************************************************************
2038  *              __libm_sse2_cosf   (MSVCRT.@)
2039  */
2040 void __cdecl __libm_sse2_cosf(void)
2041 {
2042     float f;
2043     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2044     f = cosf( f );
2045     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2046 }
2047
2048 /***********************************************************************
2049  *              __libm_sse2_exp   (MSVCRT.@)
2050  */
2051 void __cdecl __libm_sse2_exp(void)
2052 {
2053     double d;
2054     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2055     d = exp( d );
2056     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2057 }
2058
2059 /***********************************************************************
2060  *              __libm_sse2_expf   (MSVCRT.@)
2061  */
2062 void __cdecl __libm_sse2_expf(void)
2063 {
2064     float f;
2065     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2066     f = expf( f );
2067     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2068 }
2069
2070 /***********************************************************************
2071  *              __libm_sse2_log   (MSVCRT.@)
2072  */
2073 void __cdecl __libm_sse2_log(void)
2074 {
2075     double d;
2076     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2077     d = log( d );
2078     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2079 }
2080
2081 /***********************************************************************
2082  *              __libm_sse2_log10   (MSVCRT.@)
2083  */
2084 void __cdecl __libm_sse2_log10(void)
2085 {
2086     double d;
2087     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2088     d = log10( d );
2089     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2090 }
2091
2092 /***********************************************************************
2093  *              __libm_sse2_log10f   (MSVCRT.@)
2094  */
2095 void __cdecl __libm_sse2_log10f(void)
2096 {
2097     float f;
2098     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2099     f = log10f( f );
2100     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2101 }
2102
2103 /***********************************************************************
2104  *              __libm_sse2_logf   (MSVCRT.@)
2105  */
2106 void __cdecl __libm_sse2_logf(void)
2107 {
2108     float f;
2109     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2110     f = logf( f );
2111     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2112 }
2113
2114 /***********************************************************************
2115  *              __libm_sse2_pow   (MSVCRT.@)
2116  */
2117 void __cdecl __libm_sse2_pow(void)
2118 {
2119     double d1, d2;
2120     __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2121     d1 = pow( d1, d2 );
2122     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2123 }
2124
2125 /***********************************************************************
2126  *              __libm_sse2_powf   (MSVCRT.@)
2127  */
2128 void __cdecl __libm_sse2_powf(void)
2129 {
2130     float f1, f2;
2131     __asm__ __volatile__( "movd %%xmm0,%0; movd %%xmm1,%1" : "=g" (f1), "=g" (f2) );
2132     f1 = powf( f1, f2 );
2133     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f1) );
2134 }
2135
2136 /***********************************************************************
2137  *              __libm_sse2_sin   (MSVCRT.@)
2138  */
2139 void __cdecl __libm_sse2_sin(void)
2140 {
2141     double d;
2142     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2143     d = sin( d );
2144     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2145 }
2146
2147 /***********************************************************************
2148  *              __libm_sse2_sinf   (MSVCRT.@)
2149  */
2150 void __cdecl __libm_sse2_sinf(void)
2151 {
2152     float f;
2153     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2154     f = sinf( f );
2155     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2156 }
2157
2158 /***********************************************************************
2159  *              __libm_sse2_tan   (MSVCRT.@)
2160  */
2161 void __cdecl __libm_sse2_tan(void)
2162 {
2163     double d;
2164     __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2165     d = tan( d );
2166     __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2167 }
2168
2169 /***********************************************************************
2170  *              __libm_sse2_tanf   (MSVCRT.@)
2171  */
2172 void __cdecl __libm_sse2_tanf(void)
2173 {
2174     float f;
2175     __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2176     f = tanf( f );
2177     __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2178 }
2179
2180 #endif  /* __i386__ */