git.oblomov.eu Git - wine/blob - dlls/msvcrt/math.c

   1 /*
   2  * msvcrt.dll math functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  */
   6 #include "config.h"
   7 #include "msvcrt.h"
   8 #include "ms_errno.h"
   9
  10 #define __USE_ISOC9X 1
  11 #define __USE_ISOC99 1
  12 #include <math.h>
  13 #ifdef HAVE_IEEEFP_H
  14 #include <ieeefp.h>
  15 #endif
  16
  17 #include "msvcrt/stdlib.h"
  18
  19 DEFAULT_DEBUG_CHANNEL(msvcrt);
  20
  21 #ifndef HAVE_FINITE
  22 #ifndef finite /* Could be a macro */
  23 #ifdef isfinite
  24 #define finite(x) isfinite(x)
  25 #else
  26 #define finite(x) (!isnan(x)) /* At least catch some cases */
  27 #endif
  28 #endif
  29 #endif
  30
  31 #ifndef signbit
  32 #define signbit(x) 0
  33 #endif
  34
  35 /* fpclass constants */
  36 #define _FPCLASS_SNAN 1
  37 #define _FPCLASS_QNAN 2
  38 #define _FPCLASS_NINF 4
  39 #define _FPCLASS_NN   8
  40 #define _FPCLASS_ND   16
  41 #define _FPCLASS_NZ   32
  42 #define _FPCLASS_PZ   64
  43 #define _FPCLASS_PD   128
  44 #define _FPCLASS_PN   256
  45 #define _FPCLASS_PINF 512
  46
  47 /* _statusfp bit flags */
  48 #define _SW_INEXACT    0x1
  49 #define _SW_UNDERFLOW  0x2
  50 #define _SW_OVERFLOW   0x4
  51 #define _SW_ZERODIVIDE 0x8
  52 #define _SW_INVALID    0x10
  53 #define _SW_DENORMAL   0x80000
  54
  55 /* _controlfp masks and bitflags - x86 only so far*/
  56 #ifdef __i386__
  57 #define _MCW_EM        0x8001f
  58 #define _EM_INEXACT    0x1
  59 #define _EM_UNDERFLOW  0x2
  60 #define _EM_OVERFLOW   0x4
  61 #define _EM_ZERODIVIDE 0x8
  62 #define _EM_INVALID    0x10
  63
  64 #define _MCW_RC        0x300
  65 #define _RC_NEAR       0x0
  66 #define _RC_DOWN       0x100
  67 #define _RC_UP         0x200
  68 #define _RC_CHOP       0x300
  69
  70 #define _MCW_PC        0x30000
  71 #define _PC_64         0x0
  72 #define _PC_53         0x10000
  73 #define _PC_24         0x20000
  74
  75 #define _MCW_IC        0x40000
  76 #define _IC_AFFINE     0x40000
  77 #define _IC_PROJECTIVE 0x0
  78
  79 #define _EM_DENORMAL   0x80000
  80 #endif
  81
  82 typedef struct __MSVCRT_complex
  83 {
  84   double real;
  85   double imaginary;
  86 } MSVCRT_complex;
  87
  88 typedef struct __MSVCRT_exception
  89 {
  90   int type;
  91   char *name;
  92   double arg1;
  93   double arg2;
  94   double retval;
  95 } MSVCRT_exception;
  96
  97
  98 typedef int (*MSVCRT_matherr_func)(MSVCRT_exception *);
  99
 100 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
 101
 102 #if defined(__GNUC__) && defined(__i386__)
 103
 104 #define FPU_DOUBLE(var) double var; \
 105   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
 106 #define FPU_DOUBLES(var1,var2) double var1,var2; \
 107   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
 108   __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
 109
 110 /*********************************************************************
 111  *              _CIacos (MSVCRT.@)
 112  */
 113 double _CIacos(void)
 114 {
 115   FPU_DOUBLE(x);
 116   if (x < -1.0 || x > 1.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 117   return acos(x);
 118 }
 119
 120 /*********************************************************************
 121  *              _CIasin (MSVCRT.@)
 122  */
 123 double _CIasin(void)
 124 {
 125   FPU_DOUBLE(x);
 126   if (x < -1.0 || x > 1.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 127   return asin(x);
 128 }
 129
 130 /*********************************************************************
 131  *              _CIatan (MSVCRT.@)
 132  */
 133 double _CIatan(void)
 134 {
 135   FPU_DOUBLE(x);
 136   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 137   return atan(x);
 138 }
 139
 140 /*********************************************************************
 141  *              _CIatan2 (MSVCRT.@)
 142  */
 143 double _CIatan2(void)
 144 {
 145   FPU_DOUBLES(x,y);
 146   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 147   return atan2(x,y);
 148 }
 149
 150 /*********************************************************************
 151  *              _CIcos (MSVCRT.@)
 152  */
 153 double _CIcos(void)
 154 {
 155   FPU_DOUBLE(x);
 156   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 157   return cos(x);
 158 }
 159
 160 /*********************************************************************
 161  *              _CIcosh (MSVCRT.@)
 162  */
 163 double _CIcosh(void)
 164 {
 165   FPU_DOUBLE(x);
 166   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 167   return cosh(x);
 168 }
 169
 170 /*********************************************************************
 171  *              _CIexp (MSVCRT.@)
 172  */
 173 double _CIexp(void)
 174 {
 175   FPU_DOUBLE(x);
 176   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 177   return exp(x);
 178 }
 179
 180 /*********************************************************************
 181  *              _CIfmod (MSVCRT.@)
 182  */
 183 double _CIfmod(void)
 184 {
 185   FPU_DOUBLES(x,y);
 186   if (!finite(x) || !finite(y)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 187   return fmod(x,y);
 188 }
 189
 190 /*********************************************************************
 191  *              _CIlog (MSVCRT.@)
 192  */
 193 double _CIlog(void)
 194 {
 195   FPU_DOUBLE(x);
 196   if (x < 0.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 197   if (x == 0.0) SET_THREAD_VAR(errno,MSVCRT_ERANGE);
 198   return log(x);
 199 }
 200
 201 /*********************************************************************
 202  *              _CIlog10 (MSVCRT.@)
 203  */
 204 double _CIlog10(void)
 205 {
 206   FPU_DOUBLE(x);
 207   if (x < 0.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 208   if (x == 0.0) SET_THREAD_VAR(errno,MSVCRT_ERANGE);
 209   return log10(x);
 210 }
 211
 212 /*********************************************************************
 213  *              _CIpow (MSVCRT.@)
 214  */
 215 double _CIpow(void)
 216 {
 217   double z;
 218   FPU_DOUBLES(x,y);
 219   /* FIXME: If x < 0 and y is not integral, set EDOM */
 220   z = pow(x,y);
 221   if (!finite(z)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 222   return z;
 223 }
 224
 225 /*********************************************************************
 226  *              _CIsin (MSVCRT.@)
 227  */
 228 double _CIsin(void)
 229 {
 230   FPU_DOUBLE(x);
 231   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 232   return sin(x);
 233 }
 234
 235 /*********************************************************************
 236  *              _CIsinh (MSVCRT.@)
 237  */
 238 double _CIsinh(void)
 239 {
 240   FPU_DOUBLE(x);
 241   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 242   return sinh(x);
 243 }
 244
 245 /*********************************************************************
 246  *              _CIsqrt (MSVCRT.@)
 247  */
 248 double _CIsqrt(void)
 249 {
 250   FPU_DOUBLE(x);
 251   if (x < 0.0 || !finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 252   return sqrt(x);
 253 }
 254
 255 /*********************************************************************
 256  *              _CItan (MSVCRT.@)
 257  */
 258 double _CItan(void)
 259 {
 260   FPU_DOUBLE(x);
 261   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 262   return tan(x);
 263 }
 264
 265 /*********************************************************************
 266  *              _CItanh (MSVCRT.@)
 267  */
 268 double _CItanh(void)
 269 {
 270   FPU_DOUBLE(x);
 271   if (!finite(x)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 272   return tanh(x);
 273 }
 274
 275 #else /* defined(__GNUC__) && defined(__i386__) */
 276
 277 /* The above cannot be called on non x86 platforms, stub them for linking */
 278
 279 #define IX86_ONLY(func) double MSVCRT_##func(void) { return 0.0; }
 280
 281 IX86_ONLY(_CIacos)
 282 IX86_ONLY(_CIasin)
 283 IX86_ONLY(_CIatan)
 284 IX86_ONLY(_CIatan2)
 285 IX86_ONLY(_CIcos)
 286 IX86_ONLY(_CIcosh)
 287 IX86_ONLY(_CIexp)
 288 IX86_ONLY(_CIfmod)
 289 IX86_ONLY(_CIlog)
 290 IX86_ONLY(_CIlog10)
 291 IX86_ONLY(_CIpow)
 292 IX86_ONLY(_CIsin)
 293 IX86_ONLY(_CIsinh)
 294 IX86_ONLY(_CIsqrt)
 295 IX86_ONLY(_CItan)
 296 IX86_ONLY(_CItanh)
 297
 298 #endif /* defined(__GNUC__) && defined(__i386__) */
 299
 300 /*********************************************************************
 301  *              _fpclass (MSVCRT.@)
 302  */
 303 int _fpclass(double num)
 304 {
 305 #if defined(HAVE_FPCLASS) || defined(fpclass)
 306   switch (fpclass( num ))
 307   {
 308   case FP_SNAN:  return _FPCLASS_SNAN;
 309   case FP_QNAN:  return _FPCLASS_QNAN;
 310   case FP_NINF:  return _FPCLASS_NINF;
 311   case FP_PINF:  return _FPCLASS_PINF;
 312   case FP_NDENORM: return _FPCLASS_ND;
 313   case FP_PDENORM: return _FPCLASS_PD;
 314   case FP_NZERO: return _FPCLASS_NZ;
 315   case FP_PZERO: return _FPCLASS_PZ;
 316   case FP_NNORM: return _FPCLASS_NN;
 317   }
 318   return _FPCLASS_PN;
 319 #elif defined (fpclassify)
 320   switch (fpclassify( num ))
 321   {
 322   case FP_NAN: return _FPCLASS_QNAN;
 323   case FP_INFINITE: return signbit(num) ? _FPCLASS_NINF : _FPCLASS_PINF;
 324   case FP_SUBNORMAL: return signbit(num) ?_FPCLASS_ND : _FPCLASS_PD;
 325   case FP_ZERO: return signbit(num) ? _FPCLASS_NZ : _FPCLASS_PZ;
 326   }
 327   return signbit(num) ? _FPCLASS_NN : _FPCLASS_PN;
 328 #else
 329   if (!finite(num))
 330     return _FPCLASS_QNAN;
 331   return num == 0.0 ? _FPCLASS_PZ : (num < 0 ? _FPCLASS_NN : _FPCLASS_PN);
 332 #endif
 333 }
 334
 335 /*********************************************************************
 336  *              _rotl (MSVCRT.@)
 337  */
 338 unsigned int _rotl(unsigned int num, int shift)
 339 {
 340   shift &= 31;
 341   return (num << shift) | (num >> (32-shift));
 342 }
 343
 344 /*********************************************************************
 345  *              _logb (MSVCRT.@)
 346  */
 347 double _logb(double num)
 348 {
 349   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 350   return logb(num);
 351 }
 352
 353 /*********************************************************************
 354  *              _lrotl (MSVCRT.@)
 355  */
 356 unsigned long _lrotl(unsigned long num, int shift)
 357 {
 358   shift &= 0x1f;
 359   return (num << shift) | (num >> (32-shift));
 360 }
 361
 362 /*********************************************************************
 363  *              _lrotr (MSVCRT.@)
 364  */
 365 unsigned long _lrotr(unsigned long num, int shift)
 366 {
 367   shift &= 0x1f;
 368   return (num >> shift) | (num << (32-shift));
 369 }
 370
 371 /*********************************************************************
 372  *              _rotr (MSVCRT.@)
 373  */
 374 unsigned int _rotr(unsigned int num, int shift)
 375 {
 376     shift &= 0x1f;
 377     return (num >> shift) | (num << (32-shift));
 378 }
 379
 380 /*********************************************************************
 381  *              _scalb (MSVCRT.@)
 382  */
 383 double _scalb(double num, long power)
 384 {
 385   /* Note - Can't forward directly as libc expects y as double */
 386   double dblpower = (double)power;
 387   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 388   return scalb(num, dblpower);
 389 }
 390
 391 /*********************************************************************
 392  *              _matherr (MSVCRT.@)
 393  */
 394 int _matherr(MSVCRT_exception *e)
 395 {
 396   if (e)
 397     TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
 398           e->retval);
 399   else
 400     TRACE("(null)\n");
 401   if (MSVCRT_default_matherr_func)
 402     return MSVCRT_default_matherr_func(e);
 403   ERR(":Unhandled math error!\n");
 404   return 0;
 405 }
 406
 407 /*********************************************************************
 408  *              __setusermatherr (MSVCRT.@)
 409  */
 410 void MSVCRT___setusermatherr(MSVCRT_matherr_func func)
 411 {
 412   MSVCRT_default_matherr_func = func;
 413   TRACE(":new matherr handler %p\n", func);
 414 }
 415
 416 /**********************************************************************
 417  *              _statusfp (MSVCRT.@)
 418  */
 419 unsigned int _statusfp(void)
 420 {
 421    unsigned int retVal = 0;
 422 #if defined(__GNUC__) && defined(__i386__)
 423   unsigned int fpword;
 424
 425   __asm__ __volatile__( "fstsw %0" : "=m" (fpword) : );
 426   if (fpword & 0x1)  retVal |= _SW_INVALID;
 427   if (fpword & 0x2)  retVal |= _SW_DENORMAL;
 428   if (fpword & 0x4)  retVal |= _SW_ZERODIVIDE;
 429   if (fpword & 0x8)  retVal |= _SW_OVERFLOW;
 430   if (fpword & 0x10) retVal |= _SW_UNDERFLOW;
 431   if (fpword & 0x20) retVal |= _SW_INEXACT;
 432 #else
 433   FIXME(":Not implemented!\n");
 434 #endif
 435   return retVal;
 436 }
 437
 438 /*********************************************************************
 439  *              _clearfp (MSVCRT.@)
 440  */
 441 unsigned int _clearfp(void)
 442 {
 443   unsigned int retVal = _statusfp();
 444 #if defined(__GNUC__) && defined(__i386__)
 445   __asm__ __volatile__( "fnclex" );
 446 #else
 447   FIXME(":Not Implemented\n");
 448 #endif
 449   return retVal;
 450 }
 451
 452 /*********************************************************************
 453  *              ldexp (MSVCRT.@)
 454  */
 455 double MSVCRT_ldexp(double num, long exp)
 456 {
 457   double z = ldexp(num,exp);
 458
 459   if (!finite(z))
 460     SET_THREAD_VAR(errno,MSVCRT_ERANGE);
 461   else if (z == 0 && signbit(z))
 462     z = 0.0; /* Convert -0 -> +0 */
 463   return z;
 464 }
 465
 466 /*********************************************************************
 467  *              _cabs (MSVCRT.@)
 468  */
 469 double _cabs(MSVCRT_complex num)
 470 {
 471   return sqrt(num.real * num.real + num.imaginary * num.imaginary);
 472 }
 473
 474 /*********************************************************************
 475  *              _chgsign (MSVCRT.@)
 476  */
 477 double _chgsign(double num)
 478 {
 479   /* FIXME: +-infinity,Nan not tested */
 480   return -num;
 481 }
 482
 483 /*********************************************************************
 484  *              _control87 (MSVCRT.@)
 485  */
 486 unsigned int _control87(unsigned int newval, unsigned int mask)
 487 {
 488 #if defined(__GNUC__) && defined(__i386__)
 489   unsigned int fpword = 0;
 490   unsigned int flags = 0;
 491
 492   TRACE("(%08x, %08x): Called\n", newval, mask);
 493
 494   /* Get fp control word */
 495   __asm__ __volatile__( "fstcw %0" : "=m" (fpword) : );
 496
 497   TRACE("Control word before : %08x\n", fpword);
 498
 499   /* Convert into mask constants */
 500   if (fpword & 0x1)  flags |= _EM_INVALID;
 501   if (fpword & 0x2)  flags |= _EM_DENORMAL;
 502   if (fpword & 0x4)  flags |= _EM_ZERODIVIDE;
 503   if (fpword & 0x8)  flags |= _EM_OVERFLOW;
 504   if (fpword & 0x10) flags |= _EM_UNDERFLOW;
 505   if (fpword & 0x20) flags |= _EM_INEXACT;
 506   switch(fpword & 0xC00) {
 507   case 0xC00: flags |= _RC_UP|_RC_DOWN; break;
 508   case 0x800: flags |= _RC_UP; break;
 509   case 0x400: flags |= _RC_DOWN; break;
 510   }
 511   switch(fpword & 0x300) {
 512   case 0x0:   flags |= _PC_24; break;
 513   case 0x200: flags |= _PC_53; break;
 514   case 0x300: flags |= _PC_64; break;
 515   }
 516   if (fpword & 0x1000) flags |= _IC_AFFINE;
 517
 518   /* Mask with parameters */
 519   flags = (flags & ~mask) | (newval & mask);
 520
 521   /* Convert (masked) value back to fp word */
 522   fpword = 0;
 523   if (flags & _EM_INVALID)    fpword |= 0x1;
 524   if (flags & _EM_DENORMAL)   fpword |= 0x2;
 525   if (flags & _EM_ZERODIVIDE) fpword |= 0x4;
 526   if (flags & _EM_OVERFLOW)   fpword |= 0x8;
 527   if (flags & _EM_UNDERFLOW)  fpword |= 0x10;
 528   if (flags & _EM_INEXACT)    fpword |= 0x20;
 529   switch(flags & (_RC_UP | _RC_DOWN)) {
 530   case _RC_UP|_RC_DOWN: fpword |= 0xC00; break;
 531   case _RC_UP:          fpword |= 0x800; break;
 532   case _RC_DOWN:        fpword |= 0x400; break;
 533   }
 534   switch (flags & (_PC_24 | _PC_53)) {
 535   case _PC_64: fpword |= 0x300; break;
 536   case _PC_53: fpword |= 0x200; break;
 537   case _PC_24: fpword |= 0x0; break;
 538   }
 539   if (flags & _IC_AFFINE) fpword |= 0x1000;
 540
 541   TRACE("Control word after  : %08x\n", fpword);
 542
 543   /* Put fp control word */
 544   __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
 545
 546   return flags;
 547 #else
 548   FIXME(":Not Implemented!\n");
 549   return 0;
 550 #endif
 551 }
 552
 553 /*********************************************************************
 554  *              _controlfp (MSVCRT.@)
 555  */
 556 unsigned int _controlfp(unsigned int newval, unsigned int mask)
 557 {
 558   return _control87( newval, mask & ~_EM_DENORMAL );
 559 }
 560
 561 /*********************************************************************
 562  *              _copysign (MSVCRT.@)
 563  */
 564 double _copysign(double num, double sign)
 565 {
 566   /* FIXME: Behaviour for Nan/Inf? */
 567   if (sign < 0.0)
 568     return num < 0.0 ? num : -num;
 569   return num < 0.0 ? -num : num;
 570 }
 571
 572 /*********************************************************************
 573  *              _finite (MSVCRT.@)
 574  */
 575 int  _finite(double num)
 576 {
 577   return (finite(num)?1:0); /* See comment for _isnan() */
 578 }
 579
 580 /*********************************************************************
 581  *              _fpreset (MSVCRT.@)
 582  */
 583 void _fpreset(void)
 584 {
 585 #if defined(__GNUC__) && defined(__i386__)
 586   __asm__ __volatile__( "fninit" );
 587 #else
 588   FIXME(":Not Implemented!\n");
 589 #endif
 590 }
 591
 592 /*********************************************************************
 593  *              _isnan (MSVCRT.@)
 594  */
 595 INT  _isnan(double num)
 596 {
 597   /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
 598    * Do the same, as the result may be used in calculations
 599    */
 600   return isnan(num) ? 1 : 0;
 601 }
 602
 603 /*********************************************************************
 604  *              _y0 (MSVCRT.@)
 605  */
 606 double _y0(double num)
 607 {
 608   double retval;
 609   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 610   retval  = y0(num);
 611   if (_fpclass(retval) == _FPCLASS_NINF)
 612   {
 613     SET_THREAD_VAR(errno,MSVCRT_EDOM);
 614     retval = sqrt(-1);
 615   }
 616   return retval;
 617 }
 618
 619 /*********************************************************************
 620  *              _y1 (MSVCRT.@)
 621  */
 622 double _y1(double num)
 623 {
 624   double retval;
 625   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 626   retval  = y1(num);
 627   if (_fpclass(retval) == _FPCLASS_NINF)
 628   {
 629     SET_THREAD_VAR(errno,MSVCRT_EDOM);
 630     retval = sqrt(-1);
 631   }
 632   return retval;
 633 }
 634
 635 /*********************************************************************
 636  *              _yn (MSVCRT.@)
 637  */
 638 double _yn(int order, double num)
 639 {
 640   double retval;
 641   if (!finite(num)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 642   retval  = yn(order,num);
 643   if (_fpclass(retval) == _FPCLASS_NINF)
 644   {
 645     SET_THREAD_VAR(errno,MSVCRT_EDOM);
 646     retval = sqrt(-1);
 647   }
 648   return retval;
 649 }
 650
 651 /*********************************************************************
 652  *              _nextafter (MSVCRT.@)
 653  */
 654 double _nextafter(double num, double next)
 655 {
 656   double retval;
 657   if (!finite(num) || !finite(next)) SET_THREAD_VAR(errno,MSVCRT_EDOM);
 658   retval = nextafter(num,next);
 659   return retval;
 660 }
 661
 662 #include <stdlib.h> /* div_t, ldiv_t */
 663
 664 /*********************************************************************
 665  *              div (MSVCRT.@)
 666  * VERSION
 667  *      [i386] Windows binary compatible - returns the struct in eax/edx.
 668  */
 669 #ifdef __i386__
 670 LONGLONG MSVCRT_div(int num, int denom)
 671 {
 672   LONGLONG retval;
 673   div_t dt = div(num,denom);
 674   retval = ((LONGLONG)dt.rem << 32) | dt.quot;
 675   return retval;
 676 }
 677 #else
 678 /*********************************************************************
 679  *              div (MSVCRT.@)
 680  * VERSION
 681  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
 682  */
 683 MSVCRT_div_t MSVCRT_div(int num, int denom)
 684 {
 685   return div(num,denom);
 686 }
 687 #endif /* ifdef __i386__ */
 688
 689
 690 /*********************************************************************
 691  *              ldiv (MSVCRT.@)
 692  * VERSION
 693  *      [i386] Windows binary compatible - returns the struct in eax/edx.
 694  */
 695 #ifdef __i386__
 696 ULONGLONG MSVCRT_ldiv(long num, long denom)
 697 {
 698   ULONGLONG retval;
 699   ldiv_t ldt = ldiv(num,denom);
 700   retval = ((ULONGLONG)ldt.rem << 32) | (ULONG)ldt.quot;
 701   return retval;
 702 }
 703 #else
 704 /*********************************************************************
 705  *              ldiv (MSVCRT.@)
 706  * VERSION
 707  *      [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
 708  */
 709 MSVCRT_ldiv_t MSVCRT_ldiv(long num, long denom)
 710 {
 711   return ldiv(num,denom);
 712 }
 713 #endif /* ifdef __i386__ */
 714
 715 /***********************************************************************
 716  *              _adj_fdiv_m16i (MSVCRT.@)
 717  * FIXME
 718  *    This function is likely to have the wrong number of arguments.
 719  *
 720  * NOTE
 721  *    I _think_ this function is intended to work around the Pentium
 722  *    fdiv bug.
 723  */
 724 void _adj_fdiv_m16i(void)
 725 {
 726   TRACE("(): stub\n");
 727 }
 728
 729 /***********************************************************************
 730  *              _adj_fdiv_m32 (MSVCRT.@)
 731  * FIXME
 732  *    This function is likely to have the wrong number of arguments.
 733  *
 734  * NOTE
 735  *    I _think_ this function is intended to work around the Pentium
 736  *    fdiv bug.
 737  */
 738 void _adj_fdiv_m32(void)
 739 {
 740   TRACE("(): stub\n");
 741 }
 742
 743 /***********************************************************************
 744  *              _adj_fdiv_m32i (MSVCRT.@)
 745  * FIXME
 746  *    This function is likely to have the wrong number of arguments.
 747  *
 748  * NOTE
 749  *    I _think_ this function is intended to work around the Pentium
 750  *    fdiv bug.
 751  */
 752 void _adj_fdiv_m32i(void)
 753 {
 754   TRACE("(): stub\n");
 755 }
 756
 757 /***********************************************************************
 758  *              _adj_fdiv_m64 (MSVCRT.@)
 759  * FIXME
 760  *    This function is likely to have the wrong number of arguments.
 761  *
 762  * NOTE
 763  *    I _think_ this function is intended to work around the Pentium
 764  *    fdiv bug.
 765  */
 766 void _adj_fdiv_m64(void)
 767 {
 768   TRACE("(): stub\n");
 769 }
 770
 771 /***********************************************************************
 772  *              _adj_fdiv_r (MSVCRT.@)
 773  * FIXME
 774  *    This function is likely to have the wrong number of arguments.
 775  *
 776  * NOTE
 777  *    I _think_ this function is intended to work around the Pentium
 778  *    fdiv bug.
 779  */
 780 void _adj_fdiv_r(void)
 781 {
 782   TRACE("(): stub\n");
 783 }
 784
 785 /***********************************************************************
 786  *              _adj_fdivr_m16i (MSVCRT.@)
 787  * FIXME
 788  *    This function is likely to have the wrong number of arguments.
 789  *
 790  * NOTE
 791  *    I _think_ this function is intended to work around the Pentium
 792  *    fdiv bug.
 793  */
 794 void _adj_fdivr_m16i(void)
 795 {
 796   TRACE("(): stub\n");
 797 }
 798
 799 /***********************************************************************
 800  *              _adj_fdivr_m32 (MSVCRT.@)
 801  * FIXME
 802  *    This function is likely to have the wrong number of arguments.
 803  *
 804  * NOTE
 805  *    I _think_ this function is intended to work around the Pentium
 806  *    fdiv bug.
 807  */
 808 void _adj_fdivr_m32(void)
 809 {
 810   TRACE("(): stub\n");
 811 }
 812
 813 /***********************************************************************
 814  *              _adj_fdivr_m32i (MSVCRT.@)
 815  * FIXME
 816  *    This function is likely to have the wrong number of arguments.
 817  *
 818  * NOTE
 819  *    I _think_ this function is intended to work around the Pentium
 820  *    fdiv bug.
 821  */
 822 void _adj_fdivr_m32i(void)
 823 {
 824   TRACE("(): stub\n");
 825 }
 826
 827 /***********************************************************************
 828  *              _adj_fdivr_m64 (MSVCRT.@)
 829  * FIXME
 830  *    This function is likely to have the wrong number of arguments.
 831  *
 832  * NOTE
 833  *    I _think_ this function is intended to work around the Pentium
 834  *    fdiv bug.
 835  */
 836 void _adj_fdivr_m64(void)
 837 {
 838   TRACE("(): stub\n");
 839 }
 840
 841 /***********************************************************************
 842  *              _adj_fpatan (MSVCRT.@)
 843  * FIXME
 844  *    This function is likely to have the wrong number of arguments.
 845  *
 846  * NOTE
 847  *    I _think_ this function is intended to work around the Pentium
 848  *    fdiv bug.
 849  */
 850 void _adj_fpatan(void)
 851 {
 852   TRACE("(): stub\n");
 853 }
 854
 855 /***********************************************************************
 856  *              _adj_fprem (MSVCRT.@)
 857  * FIXME
 858  *    This function is likely to have the wrong number of arguments.
 859  *
 860  * NOTE
 861  *    I _think_ this function is intended to work around the Pentium
 862  *    fdiv bug.
 863  */
 864 void _adj_fprem(void)
 865 {
 866   TRACE("(): stub\n");
 867 }
 868
 869 /***********************************************************************
 870  *              _adj_fprem1 (MSVCRT.@)
 871  * FIXME
 872  *    This function is likely to have the wrong number of arguments.
 873  *
 874  * NOTE
 875  *    I _think_ this function is intended to work around the Pentium
 876  *    fdiv bug.
 877  */
 878 void _adj_fprem1(void)
 879 {
 880   TRACE("(): stub\n");
 881 }
 882
 883 /***********************************************************************
 884  *              _adj_fptan (MSVCRT.@)
 885  * FIXME
 886  *    This function is likely to have the wrong number of arguments.
 887  *
 888  * NOTE
 889  *    I _think_ this function is intended to work around the Pentium
 890  *    fdiv bug.
 891  */
 892 void _adj_fptan(void)
 893 {
 894   TRACE("(): stub\n");
 895 }
 896
 897 /***********************************************************************
 898  *              _adjust_fdiv (MSVCRT.@)
 899  * FIXME
 900  *    I _think_ this function should be a variable indicating whether
 901  *    Pentium fdiv bug safe code should be used.
 902  */
 903 void _adjust_fdiv(void)
 904 {
 905   TRACE("(): stub\n");
 906 }
 907
 908 /***********************************************************************
 909  *              _safe_fdiv (MSVCRT.@)
 910  * FIXME
 911  *    This function is likely to have the wrong number of arguments.
 912  *
 913  * NOTE
 914  *    I _think_ this function is intended to work around the Pentium
 915  *    fdiv bug.
 916  */
 917 void _safe_fdiv(void)
 918 {
 919   TRACE("(): stub\n");
 920 }
 921
 922 /***********************************************************************
 923  *              _safe_fdivr (MSVCRT.@)
 924  * FIXME
 925  *    This function is likely to have the wrong number of arguments.
 926  *
 927  * NOTE
 928  *    I _think_ this function is intended to work around the Pentium
 929  *    fdiv bug.
 930  */
 931 void _safe_fdivr(void)
 932 {
 933   TRACE("(): stub\n");
 934 }
 935
 936 /***********************************************************************
 937  *              _safe_fprem (MSVCRT.@)
 938  * FIXME
 939  *    This function is likely to have the wrong number of arguments.
 940  *
 941  * NOTE
 942  *    I _think_ this function is intended to work around the Pentium
 943  *    fdiv bug.
 944  */
 945 void _safe_fprem(void)
 946 {
 947   TRACE("(): stub\n");
 948 }
 949
 950 /***********************************************************************
 951  *              _safe_fprem1 (MSVCRT.@)
 952  *
 953  * FIXME
 954  *    This function is likely to have the wrong number of arguments.
 955  *
 956  * NOTE
 957  *    I _think_ this function is intended to work around the Pentium
 958  *    fdiv bug.
 959  */
 960 void _safe_fprem1(void)
 961 {
 962   TRACE("(): stub\n");
 963 }
 964
 965