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