?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Set errno through the _matherr function.
[wine.git] / dlls / msvcrt / math.c
bloba94c34ac80e1bfb7593d829ba566ac5cb8a4abb4
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 #include "wine/port.h"
22
23 #include <stdio.h>
24 #define __USE_ISOC9X 1
25 #define __USE_ISOC99 1
26 #include <math.h>
27 #ifdef HAVE_IEEEFP_H
28 #include <ieeefp.h>
29 #endif
30
31 #include "msvcrt.h"
32
33 #include "wine/debug.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
36
37 #ifndef HAVE_FINITEF
38 #define finitef(x) isfinite(x)
39 #endif
40
41 #ifndef HAVE_ISNANF
42 #ifdef HAVE_ISNAN
43 #define isnanf(x) isnan(x)
44 #else
45 #define isnanf(x) 0
46 #endif
47 #endif
48
49 /* FIXME: Does not work with -NAN and -0. */
50 #ifndef signbit
51 #define signbit(x) ((x) < 0)
52 #endif
53
54 #define _DOMAIN 1 /* domain error in argument */
55 #define _SING 2 /* singularity */
56 #define _OVERFLOW 3 /* range overflow */
57 #define _UNDERFLOW 4 /* range underflow */
58
59 typedef int (CDECL *MSVCRT_matherr_func)(struct MSVCRT__exception *);
60 typedef double LDOUBLE; /* long double is just a double */
61
62 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
63
64 static BOOL sse2_supported;
65 static BOOL sse2_enabled;
66
67 void msvcrt_init_math(void)
68 {
69 sse2_supported = sse2_enabled = IsProcessorFeaturePresent( PF_XMMI64_INSTRUCTIONS_AVAILABLE );
70 }
71
72 /*********************************************************************
73 * _matherr (MSVCRT.@)
74 */
75 int CDECL MSVCRT__matherr(struct MSVCRT__exception *e)
76 {
77 int ret;
78
79 if (e)
80 TRACE("(%p = {%d, \"%s\", %g, %g, %g})\n", e, e->type, e->name, e->arg1, e->arg2, e->retval);
81 else
82 TRACE("(null)\n");
83
84 if (MSVCRT_default_matherr_func)
85 {
86 ret = MSVCRT_default_matherr_func(e);
87 if (ret) return ret;
88 }
89
90 switch (e->type)
91 {
92 case _DOMAIN:
93 *MSVCRT__errno() = MSVCRT_EDOM;
94 break;
95 case _SING:
96 case _OVERFLOW:
97 *MSVCRT__errno() = MSVCRT_ERANGE;
98 break;
99 case _UNDERFLOW:
100 /* don't set errno */
101 break;
102 default:
103 ERR("Unhandled math error!\n");
104 }
105
106 return 0;
107 }
108
109 /*********************************************************************
110 * __setusermatherr (MSVCRT.@)
111 */
112 void CDECL MSVCRT___setusermatherr(MSVCRT_matherr_func func)
113 {
114 MSVCRT_default_matherr_func = func;
115 TRACE("new matherr handler %p\n", func);
116 }
117
118 static inline void math_error(int type, const char *name, double arg1, double arg2, double retval)
119 {
120 struct MSVCRT__exception exception = {type, (char *)name, arg1, arg2, retval};
121 MSVCRT__matherr(&exception);
122 }
123
124 /*********************************************************************
125 * _set_SSE2_enable (MSVCRT.@)
126 */
127 int CDECL MSVCRT__set_SSE2_enable(int flag)
128 {
129 sse2_enabled = flag && sse2_supported;
130 return sse2_enabled;
131 }
132
133 #ifdef _WIN64
134 /*********************************************************************
135 * _set_FMA3_enable (MSVCR120.@)
136 */
137 int CDECL MSVCRT__set_FMA3_enable(int flag)
138 {
139 FIXME("(%x) stub\n", flag);
140 return 0;
141 }
142 #endif
143
144 #if defined(__x86_64__) || defined(__arm__) || _MSVCR_VER>=120
145
146 /*********************************************************************
147 * _chgsignf (MSVCRT.@)
148 */
149 float CDECL MSVCRT__chgsignf( float num )
150 {
151 /* FIXME: +-infinity,Nan not tested */
152 return -num;
153 }
154
155 /*********************************************************************
156 * _copysignf (MSVCRT.@)
157 */
158 float CDECL MSVCRT__copysignf( float num, float sign )
159 {
160 if (signbit(sign))
161 return signbit(num) ? num : -num;
162 return signbit(num) ? -num : num;
163 }
164
165 /*********************************************************************
166 * _nextafterf (MSVCRT.@)
167 */
168 float CDECL MSVCRT__nextafterf( float num, float next )
169 {
170 if (!finitef(num) || !finitef(next)) *MSVCRT__errno() = MSVCRT_EDOM;
171 return nextafterf( num, next );
172 }
173
174 #endif
175 #if defined(__x86_64__) || defined(__arm__)
176
177 /*********************************************************************
178 * _finitef (MSVCRT.@)
179 */
180 int CDECL MSVCRT__finitef( float num )
181 {
182 return finitef(num) != 0; /* See comment for _isnan() */
183 }
184
185 /*********************************************************************
186 * _isnanf (MSVCRT.@)
187 */
188 INT CDECL MSVCRT__isnanf( float num )
189 {
190 /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
191 * Do the same, as the result may be used in calculations
192 */
193 return isnanf(num) != 0;
194 }
195
196 /*********************************************************************
197 * _logbf (MSVCRT.@)
198 */
199 float CDECL MSVCRT__logbf( float num )
200 {
201 float ret = logbf(num);
202 if (isnanf(num)) math_error(_DOMAIN, "_logbf", num, 0, ret);
203 else if (!num) math_error(_SING, "_logbf", num, 0, ret);
204 return ret;
205 }
206
207 /*********************************************************************
208 * MSVCRT_acosf (MSVCRT.@)
209 */
210 float CDECL MSVCRT_acosf( float x )
211 {
212 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
213 * asin() uses a similar construction. This is bad because as x gets nearer to
214 * 1 the error in the expression "1 - x^2" can get relatively large due to
215 * cancellation. The sqrt() makes things worse. A safer way to calculate
216 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
217 float ret = atan2f(sqrtf((1 - x) * (1 + x)), x);
218 if (x < -1.0 || x > 1.0 || !finitef(x)) math_error(_DOMAIN, "acosf", x, 0, ret);
219 return ret;
220 }
221
222 /*********************************************************************
223 * MSVCRT_asinf (MSVCRT.@)
224 */
225 float CDECL MSVCRT_asinf( float x )
226 {
227 float ret = atan2f(x, sqrtf((1 - x) * (1 + x)));
228 if (x < -1.0 || x > 1.0 || !finitef(x)) math_error(_DOMAIN, "asinf", x, 0, ret);
229 return ret;
230 }
231
232 /*********************************************************************
233 * MSVCRT_atanf (MSVCRT.@)
234 */
235 float CDECL MSVCRT_atanf( float x )
236 {
237 float ret = atanf(x);
238 if (!finitef(x)) math_error(_DOMAIN, "atanf", x, 0, ret);
239 return ret;
240 }
241
242 /*********************************************************************
243 * MSVCRT_atan2f (MSVCRT.@)
244 */
245 float CDECL MSVCRT_atan2f( float x, float y )
246 {
247 float ret = atan2f(x, y);
248 if (isnanf(x)) math_error(_DOMAIN, "atan2f", x, y, ret);
249 return ret;
250 }
251
252 /*********************************************************************
253 * MSVCRT_cosf (MSVCRT.@)
254 */
255 float CDECL MSVCRT_cosf( float x )
256 {
257 float ret = cosf(x);
258 if (!finitef(x)) math_error(_DOMAIN, "cosf", x, 0, ret);
259 return ret;
260 }
261
262 /*********************************************************************
263 * MSVCRT_coshf (MSVCRT.@)
264 */
265 float CDECL MSVCRT_coshf( float x )
266 {
267 float ret = coshf(x);
268 if (isnanf(x)) math_error(_DOMAIN, "coshf", x, 0, ret);
269 return ret;
270 }
271
272 /*********************************************************************
273 * MSVCRT_expf (MSVCRT.@)
274 */
275 float CDECL MSVCRT_expf( float x )
276 {
277 float ret = expf(x);
278 if (isnanf(x)) math_error(_DOMAIN, "expf", x, 0, ret);
279 else if (finitef(x) && !ret) math_error(_UNDERFLOW, "expf", x, 0, ret);
280 else if (finitef(x) && !finitef(ret)) math_error(_OVERFLOW, "expf", x, 0, ret);
281 return ret;
282 }
283
284 /*********************************************************************
285 * MSVCRT_fmodf (MSVCRT.@)
286 */
287 float CDECL MSVCRT_fmodf( float x, float y )
288 {
289 float ret = fmodf(x, y);
290 if (!finitef(x) || !finitef(y)) math_error(_DOMAIN, "fmodf", x, 0, ret);
291 return ret;
292 }
293
294 /*********************************************************************
295 * MSVCRT_logf (MSVCRT.@)
296 */
297 float CDECL MSVCRT_logf( float x )
298 {
299 float ret = logf(x);
300 if (x < 0.0) math_error(_DOMAIN, "logf", x, 0, ret);
301 else if (x == 0.0) math_error(_SING, "logf", x, 0, ret);
302 return ret;
303 }
304
305 /*********************************************************************
306 * MSVCRT_log10f (MSVCRT.@)
307 */
308 float CDECL MSVCRT_log10f( float x )
309 {
310 float ret = log10f(x);
311 if (x < 0.0) math_error(_DOMAIN, "log10f", x, 0, ret);
312 else if (x == 0.0) math_error(_SING, "log10f", x, 0, ret);
313 return ret;
314 }
315
316 /*********************************************************************
317 * MSVCRT_powf (MSVCRT.@)
318 */
319 float CDECL MSVCRT_powf( float x, float y )
320 {
321 /* FIXME: If x < 0 and y is not integral, set EDOM */
322 float z = powf(x,y);
323 if (!finitef(z)) math_error(_DOMAIN, "powf", x, 0, z);
324 return z;
325 }
326
327 /*********************************************************************
328 * MSVCRT_sinf (MSVCRT.@)
329 */
330 float CDECL MSVCRT_sinf( float x )
331 {
332 float ret = sinf(x);
333 if (!finitef(x)) math_error(_DOMAIN, "sinf", x, 0, ret);
334 return ret;
335 }
336
337 /*********************************************************************
338 * MSVCRT_sinhf (MSVCRT.@)
339 */
340 float CDECL MSVCRT_sinhf( float x )
341 {
342 float ret = sinhf(x);
343 if (isnanf(x)) math_error(_DOMAIN, "sinhf", x, 0, ret);
344 return ret;
345 }
346
347 /*********************************************************************
348 * MSVCRT_sqrtf (MSVCRT.@)
349 */
350 float CDECL MSVCRT_sqrtf( float x )
351 {
352 float ret = sqrtf(x);
353 if (x < 0.0) math_error(_DOMAIN, "sqrtf", x, 0, ret);
354 return ret;
355 }
356
357 /*********************************************************************
358 * MSVCRT_tanf (MSVCRT.@)
359 */
360 float CDECL MSVCRT_tanf( float x )
361 {
362 float ret = tanf(x);
363 if (!finitef(x)) math_error(_DOMAIN, "tanf", x, 0, ret);
364 return ret;
365 }
366
367 /*********************************************************************
368 * MSVCRT_tanhf (MSVCRT.@)
369 */
370 float CDECL MSVCRT_tanhf( float x )
371 {
372 float ret = tanhf(x);
373 if (!finitef(x)) math_error(_DOMAIN, "tanhf", x, 0, ret);
374 return ret;
375 }
376
377 /*********************************************************************
378 * ceilf (MSVCRT.@)
379 */
380 float CDECL MSVCRT_ceilf( float x )
381 {
382 return ceilf(x);
383 }
384
385 /*********************************************************************
386 * fabsf (MSVCRT.@)
387 */
388 float CDECL MSVCRT_fabsf( float x )
389 {
390 return fabsf(x);
391 }
392
393 /*********************************************************************
394 * floorf (MSVCRT.@)
395 */
396 float CDECL MSVCRT_floorf( float x )
397 {
398 return floorf(x);
399 }
400
401 /*********************************************************************
402 * frexpf (MSVCRT.@)
403 */
404 float CDECL MSVCRT_frexpf( float x, int *exp )
405 {
406 return frexpf( x, exp );
407 }
408
409 /*********************************************************************
410 * modff (MSVCRT.@)
411 */
412 float CDECL MSVCRT_modff( float x, float *iptr )
413 {
414 return modff( x, iptr );
415 }
416
417 #endif
418
419 /*********************************************************************
420 * MSVCRT_acos (MSVCRT.@)
421 */
422 double CDECL MSVCRT_acos( double x )
423 {
424 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
425 * asin() uses a similar construction. This is bad because as x gets nearer to
426 * 1 the error in the expression "1 - x^2" can get relatively large due to
427 * cancellation. The sqrt() makes things worse. A safer way to calculate
428 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
429 double ret = atan2(sqrt((1 - x) * (1 + x)), x);
430 if (x < -1.0 || x > 1.0 || !isfinite(x)) math_error(_DOMAIN, "acos", x, 0, ret);
431 return ret;
432 }
433
434 /*********************************************************************
435 * MSVCRT_asin (MSVCRT.@)
436 */
437 double CDECL MSVCRT_asin( double x )
438 {
439 double ret = atan2(x, sqrt((1 - x) * (1 + x)));
440 if (x < -1.0 || x > 1.0 || !isfinite(x)) math_error(_DOMAIN, "asin", x, 0, ret);
441 return ret;
442 }
443
444 /*********************************************************************
445 * MSVCRT_atan (MSVCRT.@)
446 */
447 double CDECL MSVCRT_atan( double x )
448 {
449 double ret = atan(x);
450 if (isnan(x)) math_error(_DOMAIN, "atan", x, 0, ret);
451 return ret;
452 }
453
454 /*********************************************************************
455 * MSVCRT_atan2 (MSVCRT.@)
456 */
457 double CDECL MSVCRT_atan2( double x, double y )
458 {
459 double ret = atan2(x, y);
460 if (isnan(x)) math_error(_DOMAIN, "atan2", x, y, ret);
461 return ret;
462 }
463
464 /*********************************************************************
465 * MSVCRT_cos (MSVCRT.@)
466 */
467 double CDECL MSVCRT_cos( double x )
468 {
469 double ret = cos(x);
470 if (!isfinite(x)) math_error(_DOMAIN, "cos", x, 0, ret);
471 return ret;
472 }
473
474 /*********************************************************************
475 * MSVCRT_cosh (MSVCRT.@)
476 */
477 double CDECL MSVCRT_cosh( double x )
478 {
479 double ret = cosh(x);
480 if (isnan(x)) math_error(_DOMAIN, "cosh", x, 0, ret);
481 return ret;
482 }
483
484 /*********************************************************************
485 * MSVCRT_exp (MSVCRT.@)
486 */
487 double CDECL MSVCRT_exp( double x )
488 {
489 double ret = exp(x);
490 if (isnan(x)) math_error(_DOMAIN, "exp", x, 0, ret);
491 else if (isfinite(x) && !ret) math_error(_UNDERFLOW, "exp", x, 0, ret);
492 else if (isfinite(x) && !isfinite(ret)) math_error(_OVERFLOW, "exp", x, 0, ret);
493 return ret;
494 }
495
496 /*********************************************************************
497 * MSVCRT_fmod (MSVCRT.@)
498 */
499 double CDECL MSVCRT_fmod( double x, double y )
500 {
501 double ret = fmod(x, y);
502 if (!isfinite(x) || !isfinite(y)) math_error(_DOMAIN, "fmod", x, y, ret);
503 return ret;
504 }
505
506 /*********************************************************************
507 * MSVCRT_log (MSVCRT.@)
508 */
509 double CDECL MSVCRT_log( double x )
510 {
511 double ret = log(x);
512 if (x < 0.0) math_error(_DOMAIN, "log", x, 0, ret);
513 else if (x == 0.0) math_error(_SING, "log", x, 0, ret);
514 return ret;
515 }
516
517 /*********************************************************************
518 * MSVCRT_log10 (MSVCRT.@)
519 */
520 double CDECL MSVCRT_log10( double x )
521 {
522 double ret = log10(x);
523 if (x < 0.0) math_error(_DOMAIN, "log10", x, 0, ret);
524 else if (x == 0.0) math_error(_SING, "log10", x, 0, ret);
525 return ret;
526 }
527
528 /*********************************************************************
529 * MSVCRT_pow (MSVCRT.@)
530 */
531 double CDECL MSVCRT_pow( double x, double y )
532 {
533 /* FIXME: If x < 0 and y is not integral, set EDOM */
534 double z = pow(x,y);
535 if (!isfinite(z)) math_error(_DOMAIN, "pow", x, y, z);
536 return z;
537 }
538
539 /*********************************************************************
540 * MSVCRT_sin (MSVCRT.@)
541 */
542 double CDECL MSVCRT_sin( double x )
543 {
544 double ret = sin(x);
545 if (!isfinite(x)) math_error(_DOMAIN, "sin", x, 0, ret);
546 return ret;
547 }
548
549 /*********************************************************************
550 * MSVCRT_sinh (MSVCRT.@)
551 */
552 double CDECL MSVCRT_sinh( double x )
553 {
554 double ret = sinh(x);
555 if (isnan(x)) math_error(_DOMAIN, "sinh", x, 0, ret);
556 return ret;
557 }
558
559 /*********************************************************************
560 * MSVCRT_sqrt (MSVCRT.@)
561 */
562 double CDECL MSVCRT_sqrt( double x )
563 {
564 double ret = sqrt(x);
565 if (x < 0.0) math_error(_DOMAIN, "sqrt", x, 0, ret);
566 return ret;
567 }
568
569 /*********************************************************************
570 * MSVCRT_tan (MSVCRT.@)
571 */
572 double CDECL MSVCRT_tan( double x )
573 {
574 double ret = tan(x);
575 if (!isfinite(x)) math_error(_DOMAIN, "tan", x, 0, ret);
576 return ret;
577 }
578
579 /*********************************************************************
580 * MSVCRT_tanh (MSVCRT.@)
581 */
582 double CDECL MSVCRT_tanh( double x )
583 {
584 double ret = tanh(x);
585 if (isnan(x)) math_error(_DOMAIN, "tanh", x, 0, ret);
586 return ret;
587 }
588
589
590 #if defined(__GNUC__) && defined(__i386__)
591
592 #define FPU_DOUBLE(var) double var; \
593 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
594 #define FPU_DOUBLES(var1,var2) double var1,var2; \
595 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
596 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
597
598 /*********************************************************************
599 * _CIacos (MSVCRT.@)
600 */
601 double CDECL _CIacos(void)
602 {
603 FPU_DOUBLE(x);
604 return MSVCRT_acos(x);
605 }
606
607 /*********************************************************************
608 * _CIasin (MSVCRT.@)
609 */
610 double CDECL _CIasin(void)
611 {
612 FPU_DOUBLE(x);
613 return MSVCRT_asin(x);
614 }
615
616 /*********************************************************************
617 * _CIatan (MSVCRT.@)
618 */
619 double CDECL _CIatan(void)
620 {
621 FPU_DOUBLE(x);
622 return MSVCRT_atan(x);
623 }
624
625 /*********************************************************************
626 * _CIatan2 (MSVCRT.@)
627 */
628 double CDECL _CIatan2(void)
629 {
630 FPU_DOUBLES(x,y);
631 return MSVCRT_atan2(x,y);
632 }
633
634 /*********************************************************************
635 * _CIcos (MSVCRT.@)
636 */
637 double CDECL _CIcos(void)
638 {
639 FPU_DOUBLE(x);
640 return MSVCRT_cos(x);
641 }
642
643 /*********************************************************************
644 * _CIcosh (MSVCRT.@)
645 */
646 double CDECL _CIcosh(void)
647 {
648 FPU_DOUBLE(x);
649 return MSVCRT_cosh(x);
650 }
651
652 /*********************************************************************
653 * _CIexp (MSVCRT.@)
654 */
655 double CDECL _CIexp(void)
656 {
657 FPU_DOUBLE(x);
658 return MSVCRT_exp(x);
659 }
660
661 /*********************************************************************
662 * _CIfmod (MSVCRT.@)
663 */
664 double CDECL _CIfmod(void)
665 {
666 FPU_DOUBLES(x,y);
667 return MSVCRT_fmod(x,y);
668 }
669
670 /*********************************************************************
671 * _CIlog (MSVCRT.@)
672 */
673 double CDECL _CIlog(void)
674 {
675 FPU_DOUBLE(x);
676 return MSVCRT_log(x);
677 }
678
679 /*********************************************************************
680 * _CIlog10 (MSVCRT.@)
681 */
682 double CDECL _CIlog10(void)
683 {
684 FPU_DOUBLE(x);
685 return MSVCRT_log10(x);
686 }
687
688 /*********************************************************************
689 * _CIpow (MSVCRT.@)
690 */
691 double CDECL _CIpow(void)
692 {
693 FPU_DOUBLES(x,y);
694 return MSVCRT_pow(x,y);
695 }
696
697 /*********************************************************************
698 * _CIsin (MSVCRT.@)
699 */
700 double CDECL _CIsin(void)
701 {
702 FPU_DOUBLE(x);
703 return MSVCRT_sin(x);
704 }
705
706 /*********************************************************************
707 * _CIsinh (MSVCRT.@)
708 */
709 double CDECL _CIsinh(void)
710 {
711 FPU_DOUBLE(x);
712 return MSVCRT_sinh(x);
713 }
714
715 /*********************************************************************
716 * _CIsqrt (MSVCRT.@)
717 */
718 double CDECL _CIsqrt(void)
719 {
720 FPU_DOUBLE(x);
721 return MSVCRT_sqrt(x);
722 }
723
724 /*********************************************************************
725 * _CItan (MSVCRT.@)
726 */
727 double CDECL _CItan(void)
728 {
729 FPU_DOUBLE(x);
730 return MSVCRT_tan(x);
731 }
732
733 /*********************************************************************
734 * _CItanh (MSVCRT.@)
735 */
736 double CDECL _CItanh(void)
737 {
738 FPU_DOUBLE(x);
739 return MSVCRT_tanh(x);
740 }
741
742 /*********************************************************************
743 * _ftol (MSVCRT.@)
744 */
745 LONGLONG CDECL MSVCRT__ftol(void)
746 {
747 FPU_DOUBLE(x);
748 return (LONGLONG)x;
749 }
750
751 #endif /* defined(__GNUC__) && defined(__i386__) */
752
753 /*********************************************************************
754 * _fpclass (MSVCRT.@)
755 */
756 int CDECL MSVCRT__fpclass(double num)
757 {
758 #if defined(HAVE_FPCLASS) || defined(fpclass)
759 switch (fpclass( num ))
760 {
761 case FP_SNAN: return MSVCRT__FPCLASS_SNAN;
762 case FP_QNAN: return MSVCRT__FPCLASS_QNAN;
763 case FP_NINF: return MSVCRT__FPCLASS_NINF;
764 case FP_PINF: return MSVCRT__FPCLASS_PINF;
765 case FP_NDENORM: return MSVCRT__FPCLASS_ND;
766 case FP_PDENORM: return MSVCRT__FPCLASS_PD;
767 case FP_NZERO: return MSVCRT__FPCLASS_NZ;
768 case FP_PZERO: return MSVCRT__FPCLASS_PZ;
769 case FP_NNORM: return MSVCRT__FPCLASS_NN;
770 case FP_PNORM: return MSVCRT__FPCLASS_PN;
771 default: return MSVCRT__FPCLASS_PN;
772 }
773 #elif defined (fpclassify)
774 switch (fpclassify( num ))
775 {
776 case FP_NAN: return MSVCRT__FPCLASS_QNAN;
777 case FP_INFINITE: return signbit(num) ? MSVCRT__FPCLASS_NINF : MSVCRT__FPCLASS_PINF;
778 case FP_SUBNORMAL: return signbit(num) ?MSVCRT__FPCLASS_ND : MSVCRT__FPCLASS_PD;
779 case FP_ZERO: return signbit(num) ? MSVCRT__FPCLASS_NZ : MSVCRT__FPCLASS_PZ;
780 }
781 return signbit(num) ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN;
782 #else
783 if (!isfinite(num))
784 return MSVCRT__FPCLASS_QNAN;
785 return num == 0.0 ? MSVCRT__FPCLASS_PZ : (num < 0 ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN);
786 #endif
787 }
788
789 /*********************************************************************
790 * _rotl (MSVCRT.@)
791 */
792 unsigned int CDECL _rotl(unsigned int num, int shift)
793 {
794 shift &= 31;
795 return (num << shift) | (num >> (32-shift));
796 }
797
798 /*********************************************************************
799 * _lrotl (MSVCRT.@)
800 */
801 MSVCRT_ulong CDECL MSVCRT__lrotl(MSVCRT_ulong num, int shift)
802 {
803 shift &= 0x1f;
804 return (num << shift) | (num >> (32-shift));
805 }
806
807 /*********************************************************************
808 * _lrotr (MSVCRT.@)
809 */
810 MSVCRT_ulong CDECL MSVCRT__lrotr(MSVCRT_ulong num, int shift)
811 {
812 shift &= 0x1f;
813 return (num >> shift) | (num << (32-shift));
814 }
815
816 /*********************************************************************
817 * _rotr (MSVCRT.@)
818 */
819 unsigned int CDECL _rotr(unsigned int num, int shift)
820 {
821 shift &= 0x1f;
822 return (num >> shift) | (num << (32-shift));
823 }
824
825 /*********************************************************************
826 * _rotl64 (MSVCRT.@)
827 */
828 unsigned __int64 CDECL _rotl64(unsigned __int64 num, int shift)
829 {
830 shift &= 63;
831 return (num << shift) | (num >> (64-shift));
832 }
833
834 /*********************************************************************
835 * _rotr64 (MSVCRT.@)
836 */
837 unsigned __int64 CDECL _rotr64(unsigned __int64 num, int shift)
838 {
839 shift &= 63;
840 return (num >> shift) | (num << (64-shift));
841 }
842
843 /*********************************************************************
844 * abs (MSVCRT.@)
845 */
846 int CDECL MSVCRT_abs( int n )
847 {
848 return n >= 0 ? n : -n;
849 }
850
851 /*********************************************************************
852 * labs (MSVCRT.@)
853 */
854 MSVCRT_long CDECL MSVCRT_labs( MSVCRT_long n )
855 {
856 return n >= 0 ? n : -n;
857 }
858
859 /*********************************************************************
860 * llabs (MSVCRT.@)
861 */
862 MSVCRT_longlong CDECL MSVCRT_llabs( MSVCRT_longlong n )
863 {
864 return n >= 0 ? n : -n;
865 }
866
867 /*********************************************************************
868 * _abs64 (MSVCRT.@)
869 */
870 __int64 CDECL _abs64( __int64 n )
871 {
872 return n >= 0 ? n : -n;
873 }
874
875 /*********************************************************************
876 * _logb (MSVCRT.@)
877 */
878 double CDECL MSVCRT__logb(double num)
879 {
880 double ret = logb(num);
881 if (isnan(num)) math_error(_DOMAIN, "_logb", num, 0, ret);
882 else if (!num) math_error(_SING, "_logb", num, 0, ret);
883 return ret;
884 }
885
886 /*********************************************************************
887 * _hypot (MSVCRT.@)
888 */
889 double CDECL _hypot(double x, double y)
890 {
891 /* FIXME: errno handling */
892 return hypot( x, y );
893 }
894
895 /*********************************************************************
896 * _hypotf (MSVCRT.@)
897 */
898 float CDECL MSVCRT__hypotf(float x, float y)
899 {
900 /* FIXME: errno handling */
901 return hypotf( x, y );
902 }
903
904 /*********************************************************************
905 * ceil (MSVCRT.@)
906 */
907 double CDECL MSVCRT_ceil( double x )
908 {
909 return ceil(x);
910 }
911
912 /*********************************************************************
913 * floor (MSVCRT.@)
914 */
915 double CDECL MSVCRT_floor( double x )
916 {
917 return floor(x);
918 }
919
920 /*********************************************************************
921 * fabs (MSVCRT.@)
922 */
923 double CDECL MSVCRT_fabs( double x )
924 {
925 return fabs(x);
926 }
927
928 /*********************************************************************
929 * frexp (MSVCRT.@)
930 */
931 double CDECL MSVCRT_frexp( double x, int *exp )
932 {
933 return frexp( x, exp );
934 }
935
936 /*********************************************************************
937 * modf (MSVCRT.@)
938 */
939 double CDECL MSVCRT_modf( double x, double *iptr )
940 {
941 return modf( x, iptr );
942 }
943
944 /**********************************************************************
945 * _statusfp2 (MSVCRT.@)
946 *
947 * Not exported by native msvcrt, added in msvcr80.
948 */
949 #if defined(__i386__) || defined(__x86_64__)
950 void CDECL _statusfp2( unsigned int *x86_sw, unsigned int *sse2_sw )
951 {
952 #ifdef __GNUC__
953 unsigned int flags;
954 unsigned long fpword;
955
956 if (x86_sw)
957 {
958 __asm__ __volatile__( "fstsw %0" : "=m" (fpword) );
959 flags = 0;
960 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
961 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
962 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
963 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
964 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
965 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
966 *x86_sw = flags;
967 }
968
969 if (!sse2_sw) return;
970
971 if (sse2_supported)
972 {
973 __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
974 flags = 0;
975 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
976 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
977 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
978 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
979 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
980 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
981 *sse2_sw = flags;
982 }
983 else *sse2_sw = 0;
984 #else
985 FIXME( "not implemented\n" );
986 #endif
987 }
988 #endif
989
990 /**********************************************************************
991 * _statusfp (MSVCRT.@)
992 */
993 unsigned int CDECL _statusfp(void)
994 {
995 #if defined(__i386__) || defined(__x86_64__)
996 unsigned int x86_sw, sse2_sw;
997
998 _statusfp2( &x86_sw, &sse2_sw );
999 /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
1000 return x86_sw | sse2_sw;
1001 #else
1002 FIXME( "not implemented\n" );
1003 return 0;
1004 #endif
1005 }
1006
1007 /*********************************************************************
1008 * _clearfp (MSVCRT.@)
1009 */
1010 unsigned int CDECL _clearfp(void)
1011 {
1012 unsigned int flags = 0;
1013 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1014 unsigned long fpword;
1015
1016 __asm__ __volatile__( "fnstsw %0; fnclex" : "=m" (fpword) );
1017 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
1018 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
1019 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
1020 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
1021 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
1022 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
1023
1024 if (sse2_supported)
1025 {
1026 __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
1027 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
1028 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
1029 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
1030 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
1031 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
1032 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
1033 fpword &= ~0x3f;
1034 __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
1035 }
1036 #else
1037 FIXME( "not implemented\n" );
1038 #endif
1039 return flags;
1040 }
1041
1042 /*********************************************************************
1043 * __fpecode (MSVCRT.@)
1044 */
1045 int * CDECL __fpecode(void)
1046 {
1047 return &msvcrt_get_thread_data()->fpecode;
1048 }
1049
1050 /*********************************************************************
1051 * ldexp (MSVCRT.@)
1052 */
1053 double CDECL MSVCRT_ldexp(double num, MSVCRT_long exp)
1054 {
1055 double z = ldexp(num,exp);
1056
1057 if (isfinite(num) && !isfinite(z))
1058 math_error(_OVERFLOW, "ldexp", num, exp, z);
1059 else if (isfinite(num) && !z)
1060 math_error(_UNDERFLOW, "ldexp", num, exp, z);
1061 else if (z == 0 && signbit(z))
1062 z = 0.0; /* Convert -0 -> +0 */
1063 return z;
1064 }
1065
1066 /*********************************************************************
1067 * _cabs (MSVCRT.@)
1068 */
1069 double CDECL MSVCRT__cabs(struct MSVCRT__complex num)
1070 {
1071 return sqrt(num.x * num.x + num.y * num.y);
1072 }
1073
1074 /*********************************************************************
1075 * _chgsign (MSVCRT.@)
1076 */
1077 double CDECL MSVCRT__chgsign(double num)
1078 {
1079 /* FIXME: +-infinity,Nan not tested */
1080 return -num;
1081 }
1082
1083 /*********************************************************************
1084 * __control87_2 (MSVCRT.@)
1085 *
1086 * Not exported by native msvcrt, added in msvcr80.
1087 */
1088 #if defined(__i386__) || defined(__x86_64__)
1089 int CDECL __control87_2( unsigned int newval, unsigned int mask,
1090 unsigned int *x86_cw, unsigned int *sse2_cw )
1091 {
1092 #ifdef __GNUC__
1093 unsigned long fpword;
1094 unsigned int flags;
1095
1096 if (x86_cw)
1097 {
1098 __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
1099
1100 /* Convert into mask constants */
1101 flags = 0;
1102 if (fpword & 0x1) flags |= MSVCRT__EM_INVALID;
1103 if (fpword & 0x2) flags |= MSVCRT__EM_DENORMAL;
1104 if (fpword & 0x4) flags |= MSVCRT__EM_ZERODIVIDE;
1105 if (fpword & 0x8) flags |= MSVCRT__EM_OVERFLOW;
1106 if (fpword & 0x10) flags |= MSVCRT__EM_UNDERFLOW;
1107 if (fpword & 0x20) flags |= MSVCRT__EM_INEXACT;
1108 switch (fpword & 0xc00)
1109 {
1110 case 0xc00: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1111 case 0x800: flags |= MSVCRT__RC_UP; break;
1112 case 0x400: flags |= MSVCRT__RC_DOWN; break;
1113 }
1114 switch (fpword & 0x300)
1115 {
1116 case 0x0: flags |= MSVCRT__PC_24; break;
1117 case 0x200: flags |= MSVCRT__PC_53; break;
1118 case 0x300: flags |= MSVCRT__PC_64; break;
1119 }
1120 if (fpword & 0x1000) flags |= MSVCRT__IC_AFFINE;
1121
1122 TRACE( "x86 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1123 if (mask)
1124 {
1125 flags = (flags & ~mask) | (newval & mask);
1126
1127 /* Convert (masked) value back to fp word */
1128 fpword = 0;
1129 if (flags & MSVCRT__EM_INVALID) fpword |= 0x1;
1130 if (flags & MSVCRT__EM_DENORMAL) fpword |= 0x2;
1131 if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x4;
1132 if (flags & MSVCRT__EM_OVERFLOW) fpword |= 0x8;
1133 if (flags & MSVCRT__EM_UNDERFLOW) fpword |= 0x10;
1134 if (flags & MSVCRT__EM_INEXACT) fpword |= 0x20;
1135 switch (flags & MSVCRT__MCW_RC)
1136 {
1137 case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0xc00; break;
1138 case MSVCRT__RC_UP: fpword |= 0x800; break;
1139 case MSVCRT__RC_DOWN: fpword |= 0x400; break;
1140 }
1141 switch (flags & MSVCRT__MCW_PC)
1142 {
1143 case MSVCRT__PC_64: fpword |= 0x300; break;
1144 case MSVCRT__PC_53: fpword |= 0x200; break;
1145 case MSVCRT__PC_24: fpword |= 0x0; break;
1146 }
1147 if (flags & MSVCRT__IC_AFFINE) fpword |= 0x1000;
1148
1149 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
1150 }
1151 *x86_cw = flags;
1152 }
1153
1154 if (!sse2_cw) return 1;
1155
1156 if (sse2_supported)
1157 {
1158 __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
1159
1160 /* Convert into mask constants */
1161 flags = 0;
1162 if (fpword & 0x80) flags |= MSVCRT__EM_INVALID;
1163 if (fpword & 0x100) flags |= MSVCRT__EM_DENORMAL;
1164 if (fpword & 0x200) flags |= MSVCRT__EM_ZERODIVIDE;
1165 if (fpword & 0x400) flags |= MSVCRT__EM_OVERFLOW;
1166 if (fpword & 0x800) flags |= MSVCRT__EM_UNDERFLOW;
1167 if (fpword & 0x1000) flags |= MSVCRT__EM_INEXACT;
1168 switch (fpword & 0x6000)
1169 {
1170 case 0x6000: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1171 case 0x4000: flags |= MSVCRT__RC_UP; break;
1172 case 0x2000: flags |= MSVCRT__RC_DOWN; break;
1173 }
1174 switch (fpword & 0x8040)
1175 {
1176 case 0x0040: flags |= MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS; break;
1177 case 0x8000: flags |= MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS; break;
1178 case 0x8040: flags |= MSVCRT__DN_FLUSH; break;
1179 }
1180
1181 TRACE( "sse2 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1182 if (mask)
1183 {
1184 flags = (flags & ~mask) | (newval & mask);
1185
1186 /* Convert (masked) value back to fp word */
1187 fpword = 0;
1188 if (flags & MSVCRT__EM_INVALID) fpword |= 0x80;
1189 if (flags & MSVCRT__EM_DENORMAL) fpword |= 0x100;
1190 if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x200;
1191 if (flags & MSVCRT__EM_OVERFLOW) fpword |= 0x400;
1192 if (flags & MSVCRT__EM_UNDERFLOW) fpword |= 0x800;
1193 if (flags & MSVCRT__EM_INEXACT) fpword |= 0x1000;
1194 switch (flags & MSVCRT__MCW_RC)
1195 {
1196 case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0x6000; break;
1197 case MSVCRT__RC_UP: fpword |= 0x4000; break;
1198 case MSVCRT__RC_DOWN: fpword |= 0x2000; break;
1199 }
1200 switch (flags & MSVCRT__MCW_DN)
1201 {
1202 case MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS: fpword |= 0x0040; break;
1203 case MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS: fpword |= 0x8000; break;
1204 case MSVCRT__DN_FLUSH: fpword |= 0x8040; break;
1205 }
1206 __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
1207 }
1208 *sse2_cw = flags;
1209 }
1210 else *sse2_cw = 0;
1211
1212 return 1;
1213 #else
1214 FIXME( "not implemented\n" );
1215 return 0;
1216 #endif
1217 }
1218 #endif
1219
1220 /*********************************************************************
1221 * _control87 (MSVCRT.@)
1222 */
1223 unsigned int CDECL _control87(unsigned int newval, unsigned int mask)
1224 {
1225 #if defined(__i386__) || defined(__x86_64__)
1226 unsigned int x86_cw, sse2_cw;
1227
1228 __control87_2( newval, mask, &x86_cw, &sse2_cw );
1229
1230 if ((x86_cw ^ sse2_cw) & (MSVCRT__MCW_EM | MSVCRT__MCW_RC)) x86_cw |= MSVCRT__EM_AMBIGUOUS;
1231 return x86_cw;
1232 #else
1233 FIXME( "not implemented\n" );
1234 return 0;
1235 #endif
1236 }
1237
1238 /*********************************************************************
1239 * _controlfp (MSVCRT.@)
1240 */
1241 unsigned int CDECL _controlfp(unsigned int newval, unsigned int mask)
1242 {
1243 return _control87( newval, mask & ~MSVCRT__EM_DENORMAL );
1244 }
1245
1246 /*********************************************************************
1247 * _set_controlfp (MSVCRT.@)
1248 */
1249 void CDECL _set_controlfp( unsigned int newval, unsigned int mask )
1250 {
1251 _controlfp( newval, mask );
1252 }
1253
1254 /*********************************************************************
1255 * _controlfp_s (MSVCRT.@)
1256 */
1257 int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
1258 {
1259 static const unsigned int all_flags = (MSVCRT__MCW_EM | MSVCRT__MCW_IC | MSVCRT__MCW_RC |
1260 MSVCRT__MCW_PC | MSVCRT__MCW_DN);
1261 unsigned int val;
1262
1263 if (!MSVCRT_CHECK_PMT( !(newval & mask & ~all_flags) ))
1264 {
1265 if (cur) *cur = _controlfp( 0, 0 ); /* retrieve it anyway */
1266 return MSVCRT_EINVAL;
1267 }
1268 val = _controlfp( newval, mask );
1269 if (cur) *cur = val;
1270 return 0;
1271 }
1272
1273 /*********************************************************************
1274 * fegetenv (MSVCR120.@)
1275 */
1276 int CDECL MSVCRT_fegetenv(MSVCRT_fenv_t *env)
1277 {
1278 env->control = _controlfp(0, 0) & (MSVCRT__EM_INEXACT | MSVCRT__EM_UNDERFLOW |
1279 MSVCRT__EM_OVERFLOW | MSVCRT__EM_ZERODIVIDE | MSVCRT__EM_INVALID);
1280 env->status = _statusfp();
1281 return 0;
1282 }
1283
1284 /*********************************************************************
1285 * __fpe_flt_rounds (UCRTBASE.@)
1286 */
1287 int CDECL __fpe_flt_rounds(void)
1288 {
1289 unsigned int fpc = _controlfp(0, 0) & MSVCRT__RC_CHOP;
1290
1291 TRACE("()\n");
1292
1293 switch(fpc) {
1294 case MSVCRT__RC_CHOP: return 0;
1295 case MSVCRT__RC_NEAR: return 1;
1296 #ifdef _WIN64
1297 case MSVCRT__RC_UP: return 3;
1298 default: return 2;
1299 #else
1300 case MSVCRT__RC_UP: return 2;
1301 default: return 3;
1302 #endif
1303 }
1304 }
1305
1306 /*********************************************************************
1307 * fegetround (MSVCR120.@)
1308 */
1309 int CDECL MSVCRT_fegetround(void)
1310 {
1311 return _controlfp(0, 0) & MSVCRT__RC_CHOP;
1312 }
1313
1314 /*********************************************************************
1315 * fesetround (MSVCR120.@)
1316 */
1317 int CDECL MSVCRT_fesetround(int round_mode)
1318 {
1319 if (round_mode & (~MSVCRT__RC_CHOP))
1320 return 1;
1321 _controlfp(round_mode, MSVCRT__RC_CHOP);
1322 return 0;
1323 }
1324
1325 /*********************************************************************
1326 * _copysign (MSVCRT.@)
1327 */
1328 double CDECL MSVCRT__copysign(double num, double sign)
1329 {
1330 if (signbit(sign))
1331 return signbit(num) ? num : -num;
1332 return signbit(num) ? -num : num;
1333 }
1334
1335 /*********************************************************************
1336 * _finite (MSVCRT.@)
1337 */
1338 int CDECL MSVCRT__finite(double num)
1339 {
1340 return isfinite(num) != 0; /* See comment for _isnan() */
1341 }
1342
1343 /*********************************************************************
1344 * _fpreset (MSVCRT.@)
1345 */
1346 void CDECL _fpreset(void)
1347 {
1348 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1349 const unsigned int x86_cw = 0x27f;
1350 __asm__ __volatile__( "fninit; fldcw %0" : : "m" (x86_cw) );
1351 if (sse2_supported)
1352 {
1353 const unsigned long sse2_cw = 0x1f80;
1354 __asm__ __volatile__( "ldmxcsr %0" : : "m" (sse2_cw) );
1355 }
1356 #else
1357 FIXME( "not implemented\n" );
1358 #endif
1359 }
1360
1361 /*********************************************************************
1362 * fesetenv (MSVCR120.@)
1363 */
1364 int CDECL MSVCRT_fesetenv(const MSVCRT_fenv_t *env)
1365 {
1366 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1367 struct {
1368 WORD control_word;
1369 WORD unused1;
1370 WORD status_word;
1371 WORD unused2;
1372 WORD tag_word;
1373 WORD unused3;
1374 DWORD instruction_pointer;
1375 WORD code_segment;
1376 WORD unused4;
1377 DWORD operand_addr;
1378 WORD data_segment;
1379 WORD unused5;
1380 } fenv;
1381
1382 TRACE( "(%p)\n", env );
1383
1384 if (!env->control && !env->status) {
1385 _fpreset();
1386 return 0;
1387 }
1388
1389 __asm__ __volatile__( "fnstenv %0" : "=m" (fenv) );
1390
1391 fenv.control_word &= ~0x3d;
1392 if (env->control & MSVCRT__EM_INVALID) fenv.control_word |= 0x1;
1393 if (env->control & MSVCRT__EM_ZERODIVIDE) fenv.control_word |= 0x4;
1394 if (env->control & MSVCRT__EM_OVERFLOW) fenv.control_word |= 0x8;
1395 if (env->control & MSVCRT__EM_UNDERFLOW) fenv.control_word |= 0x10;
1396 if (env->control & MSVCRT__EM_INEXACT) fenv.control_word |= 0x20;
1397
1398 fenv.status_word &= ~0x3d;
1399 if (env->status & MSVCRT__SW_INVALID) fenv.status_word |= 0x1;
1400 if (env->status & MSVCRT__SW_ZERODIVIDE) fenv.status_word |= 0x4;
1401 if (env->status & MSVCRT__SW_OVERFLOW) fenv.status_word |= 0x8;
1402 if (env->status & MSVCRT__SW_UNDERFLOW) fenv.status_word |= 0x10;
1403 if (env->status & MSVCRT__SW_INEXACT) fenv.status_word |= 0x20;
1404
1405 __asm__ __volatile__( "fldenv %0" : : "m" (fenv) : "st", "st(1)",
1406 "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)" );
1407
1408 if (sse2_supported)
1409 {
1410 DWORD fpword;
1411
1412 __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
1413 fpword &= ~0x1e80;
1414 if (env->control & MSVCRT__EM_INVALID) fpword |= 0x80;
1415 if (env->control & MSVCRT__EM_ZERODIVIDE) fpword |= 0x200;
1416 if (env->control & MSVCRT__EM_OVERFLOW) fpword |= 0x400;
1417 if (env->control & MSVCRT__EM_UNDERFLOW) fpword |= 0x800;
1418 if (env->control & MSVCRT__EM_INEXACT) fpword |= 0x1000;
1419 __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
1420 }
1421
1422 return 0;
1423 #else
1424 FIXME( "not implemented\n" );
1425 #endif
1426 return 1;
1427 }
1428
1429 /*********************************************************************
1430 * _isnan (MSVCRT.@)
1431 */
1432 INT CDECL MSVCRT__isnan(double num)
1433 {
1434 /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
1435 * Do the same, as the result may be used in calculations
1436 */
1437 return isnan(num) != 0;
1438 }
1439
1440 /*********************************************************************
1441 * _j0 (MSVCRT.@)
1442 */
1443 double CDECL MSVCRT__j0(double num)
1444 {
1445 /* FIXME: errno handling */
1446 return j0(num);
1447 }
1448
1449 /*********************************************************************
1450 * _j1 (MSVCRT.@)
1451 */
1452 double CDECL MSVCRT__j1(double num)
1453 {
1454 /* FIXME: errno handling */
1455 return j1(num);
1456 }
1457
1458 /*********************************************************************
1459 * _jn (MSVCRT.@)
1460 */
1461 double CDECL MSVCRT__jn(int n, double num)
1462 {
1463 /* FIXME: errno handling */
1464 return jn(n, num);
1465 }
1466
1467 /*********************************************************************
1468 * _y0 (MSVCRT.@)
1469 */
1470 double CDECL MSVCRT__y0(double num)
1471 {
1472 double retval;
1473 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1474 retval = y0(num);
1475 if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1476 {
1477 *MSVCRT__errno() = MSVCRT_EDOM;
1478 retval = sqrt(-1);
1479 }
1480 return retval;
1481 }
1482
1483 /*********************************************************************
1484 * _y1 (MSVCRT.@)
1485 */
1486 double CDECL MSVCRT__y1(double num)
1487 {
1488 double retval;
1489 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1490 retval = y1(num);
1491 if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1492 {
1493 *MSVCRT__errno() = MSVCRT_EDOM;
1494 retval = sqrt(-1);
1495 }
1496 return retval;
1497 }
1498
1499 /*********************************************************************
1500 * _yn (MSVCRT.@)
1501 */
1502 double CDECL MSVCRT__yn(int order, double num)
1503 {
1504 double retval;
1505 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1506 retval = yn(order,num);
1507 if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1508 {
1509 *MSVCRT__errno() = MSVCRT_EDOM;
1510 retval = sqrt(-1);
1511 }
1512 return retval;
1513 }
1514
1515 /*********************************************************************
1516 * _nearbyint (MSVCRT.@)
1517 */
1518 double CDECL MSVCRT_nearbyint(double num)
1519 {
1520 #ifdef HAVE_NEARBYINT
1521 return nearbyint(num);
1522 #else
1523 return num >= 0 ? floor(num + 0.5) : ceil(num - 0.5);
1524 #endif
1525 }
1526
1527 /*********************************************************************
1528 * _nearbyintf (MSVCRT.@)
1529 */
1530 float CDECL MSVCRT_nearbyintf(float num)
1531 {
1532 #ifdef HAVE_NEARBYINTF
1533 return nearbyintf(num);
1534 #else
1535 return MSVCRT_nearbyint(num);
1536 #endif
1537 }
1538
1539 /*********************************************************************
1540 * _nextafter (MSVCRT.@)
1541 */
1542 double CDECL MSVCRT__nextafter(double num, double next)
1543 {
1544 double retval;
1545 if (!isfinite(num) || !isfinite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
1546 retval = nextafter(num,next);
1547 return retval;
1548 }
1549
1550 /*********************************************************************
1551 * _ecvt (MSVCRT.@)
1552 */
1553 char * CDECL MSVCRT__ecvt( double number, int ndigits, int *decpt, int *sign )
1554 {
1555 int prec, len;
1556 thread_data_t *data = msvcrt_get_thread_data();
1557 /* FIXME: check better for overflow (native supports over 300 chars) */
1558 ndigits = min( ndigits, 80 - 7); /* 7 : space for dec point, 1 for "e",
1559 * 4 for exponent and one for
1560 * terminating '\0' */
1561 if (!data->efcvt_buffer)
1562 data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1563
1564 if( number < 0) {
1565 *sign = TRUE;
1566 number = -number;
1567 } else
1568 *sign = FALSE;
1569 /* handle cases with zero ndigits or less */
1570 prec = ndigits;
1571 if( prec < 1) prec = 2;
1572 len = snprintf(data->efcvt_buffer, 80, "%.*le", prec - 1, number);
1573 /* take the decimal "point away */
1574 if( prec != 1)
1575 memmove( data->efcvt_buffer + 1, data->efcvt_buffer + 2, len - 1 );
1576 /* take the exponential "e" out */
1577 data->efcvt_buffer[ prec] = '\0';
1578 /* read the exponent */
1579 sscanf( data->efcvt_buffer + prec + 1, "%d", decpt);
1580 (*decpt)++;
1581 /* adjust for some border cases */
1582 if( data->efcvt_buffer[0] == '0')/* value is zero */
1583 *decpt = 0;
1584 /* handle cases with zero ndigits or less */
1585 if( ndigits < 1){
1586 if( data->efcvt_buffer[ 0] >= '5')
1587 (*decpt)++;
1588 data->efcvt_buffer[ 0] = '\0';
1589 }
1590 TRACE("out=\"%s\"\n",data->efcvt_buffer);
1591 return data->efcvt_buffer;
1592 }
1593
1594 /*********************************************************************
1595 * _ecvt_s (MSVCRT.@)
1596 */
1597 int CDECL MSVCRT__ecvt_s( char *buffer, MSVCRT_size_t length, double number, int ndigits, int *decpt, int *sign )
1598 {
1599 int prec, len;
1600 char *result;
1601 const char infret[] = "1#INF";
1602
1603 if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
1604 if (!MSVCRT_CHECK_PMT(decpt != NULL)) return MSVCRT_EINVAL;
1605 if (!MSVCRT_CHECK_PMT(sign != NULL)) return MSVCRT_EINVAL;
1606 if (!MSVCRT_CHECK_PMT_ERR( length > 2, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1607 if (!MSVCRT_CHECK_PMT_ERR(ndigits < (int)length - 1, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1608
1609 /* special case - inf */
1610 if(number == HUGE_VAL || number == -HUGE_VAL)
1611 {
1612 memset(buffer, '0', ndigits);
1613 memcpy(buffer, infret, min(ndigits, sizeof(infret) - 1 ) );
1614 buffer[ndigits] = '\0';
1615 (*decpt) = 1;
1616 if(number == -HUGE_VAL)
1617 (*sign) = 1;
1618 else
1619 (*sign) = 0;
1620 return 0;
1621 }
1622 /* handle cases with zero ndigits or less */
1623 prec = ndigits;
1624 if( prec < 1) prec = 2;
1625 result = MSVCRT_malloc(prec + 7);
1626
1627 if( number < 0) {
1628 *sign = TRUE;
1629 number = -number;
1630 } else
1631 *sign = FALSE;
1632 len = snprintf(result, prec + 7, "%.*le", prec - 1, number);
1633 /* take the decimal "point away */
1634 if( prec != 1)
1635 memmove( result + 1, result + 2, len - 1 );
1636 /* take the exponential "e" out */
1637 result[ prec] = '\0';
1638 /* read the exponent */
1639 sscanf( result + prec + 1, "%d", decpt);
1640 (*decpt)++;
1641 /* adjust for some border cases */
1642 if( result[0] == '0')/* value is zero */
1643 *decpt = 0;
1644 /* handle cases with zero ndigits or less */
1645 if( ndigits < 1){
1646 if( result[ 0] >= '5')
1647 (*decpt)++;
1648 result[ 0] = '\0';
1649 }
1650 memcpy( buffer, result, max(ndigits + 1, 1) );
1651 MSVCRT_free( result );
1652 return 0;
1653 }
1654
1655 /***********************************************************************
1656 * _fcvt (MSVCRT.@)
1657 */
1658 char * CDECL MSVCRT__fcvt( double number, int ndigits, int *decpt, int *sign )
1659 {
1660 thread_data_t *data = msvcrt_get_thread_data();
1661 int stop, dec1, dec2;
1662 char *ptr1, *ptr2, *first;
1663 char buf[80]; /* ought to be enough */
1664
1665 if (!data->efcvt_buffer)
1666 data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1667
1668 if (number < 0)
1669 {
1670 *sign = 1;
1671 number = -number;
1672 } else *sign = 0;
1673
1674 stop = snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1675 ptr1 = buf;
1676 ptr2 = data->efcvt_buffer;
1677 first = NULL;
1678 dec1 = 0;
1679 dec2 = 0;
1680
1681 /* For numbers below the requested resolution, work out where
1682 the decimal point will be rather than finding it in the string */
1683 if (number < 1.0 && number > 0.0) {
1684 dec2 = log10(number + 1e-10);
1685 if (-dec2 <= ndigits) dec2 = 0;
1686 }
1687
1688 /* If requested digits is zero or less, we will need to truncate
1689 * the returned string */
1690 if (ndigits < 1) {
1691 stop += ndigits;
1692 }
1693
1694 while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1695 while (*ptr1 != '\0' && *ptr1 != '.') {
1696 if (!first) first = ptr2;
1697 if ((ptr1 - buf) < stop) {
1698 *ptr2++ = *ptr1++;
1699 } else {
1700 ptr1++;
1701 }
1702 dec1++;
1703 }
1704
1705 if (ndigits > 0) {
1706 ptr1++;
1707 if (!first) {
1708 while (*ptr1 == '0') { /* Process leading zeroes */
1709 *ptr2++ = *ptr1++;
1710 dec1--;
1711 }
1712 }
1713 while (*ptr1 != '\0') {
1714 if (!first) first = ptr2;
1715 *ptr2++ = *ptr1++;
1716 }
1717 }
1718
1719 *ptr2 = '\0';
1720
1721 /* We never found a non-zero digit, then our number is either
1722 * smaller than the requested precision, or 0.0 */
1723 if (!first) {
1724 if (number > 0.0) {
1725 first = ptr2;
1726 } else {
1727 first = data->efcvt_buffer;
1728 dec1 = 0;
1729 }
1730 }
1731
1732 *decpt = dec2 ? dec2 : dec1;
1733 return first;
1734 }
1735
1736 /***********************************************************************
1737 * _fcvt_s (MSVCRT.@)
1738 */
1739 int CDECL MSVCRT__fcvt_s(char* outbuffer, MSVCRT_size_t size, double number, int ndigits, int *decpt, int *sign)
1740 {
1741 int stop, dec1, dec2;
1742 char *ptr1, *ptr2, *first;
1743 char buf[80]; /* ought to be enough */
1744
1745 if (!outbuffer || !decpt || !sign || size == 0)
1746 {
1747 *MSVCRT__errno() = MSVCRT_EINVAL;
1748 return MSVCRT_EINVAL;
1749 }
1750
1751 if (number < 0)
1752 {
1753 *sign = 1;
1754 number = -number;
1755 } else *sign = 0;
1756
1757 stop = snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1758 ptr1 = buf;
1759 ptr2 = outbuffer;
1760 first = NULL;
1761 dec1 = 0;
1762 dec2 = 0;
1763
1764 /* For numbers below the requested resolution, work out where
1765 the decimal point will be rather than finding it in the string */
1766 if (number < 1.0 && number > 0.0) {
1767 dec2 = log10(number + 1e-10);
1768 if (-dec2 <= ndigits) dec2 = 0;
1769 }
1770
1771 /* If requested digits is zero or less, we will need to truncate
1772 * the returned string */
1773 if (ndigits < 1) {
1774 stop += ndigits;
1775 }
1776
1777 while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1778 while (*ptr1 != '\0' && *ptr1 != '.') {
1779 if (!first) first = ptr2;
1780 if ((ptr1 - buf) < stop) {
1781 if (size > 1) {
1782 *ptr2++ = *ptr1++;
1783 size--;
1784 }
1785 } else {
1786 ptr1++;
1787 }
1788 dec1++;
1789 }
1790
1791 if (ndigits > 0) {
1792 ptr1++;
1793 if (!first) {
1794 while (*ptr1 == '0') { /* Process leading zeroes */
1795 if (number == 0.0 && size > 1) {
1796 *ptr2++ = '0';
1797 size--;
1798 }
1799 ptr1++;
1800 dec1--;
1801 }
1802 }
1803 while (*ptr1 != '\0') {
1804 if (!first) first = ptr2;
1805 if (size > 1) {
1806 *ptr2++ = *ptr1++;
1807 size--;
1808 }
1809 }
1810 }
1811
1812 *ptr2 = '\0';
1813
1814 /* We never found a non-zero digit, then our number is either
1815 * smaller than the requested precision, or 0.0 */
1816 if (!first && (number <= 0.0))
1817 dec1 = 0;
1818
1819 *decpt = dec2 ? dec2 : dec1;
1820 return 0;
1821 }
1822
1823 /***********************************************************************
1824 * _gcvt (MSVCRT.@)
1825 */
1826 char * CDECL MSVCRT__gcvt( double number, int ndigit, char *buff )
1827 {
1828 if(!buff) {
1829 *MSVCRT__errno() = MSVCRT_EINVAL;
1830 return NULL;
1831 }
1832
1833 if(ndigit < 0) {
1834 *MSVCRT__errno() = MSVCRT_ERANGE;
1835 return NULL;
1836 }
1837
1838 MSVCRT_sprintf(buff, "%.*g", ndigit, number);
1839 return buff;
1840 }
1841
1842 /***********************************************************************
1843 * _gcvt_s (MSVCRT.@)
1844 */
1845 int CDECL MSVCRT__gcvt_s(char *buff, MSVCRT_size_t size, double number, int digits)
1846 {
1847 int len;
1848
1849 if(!buff) {
1850 *MSVCRT__errno() = MSVCRT_EINVAL;
1851 return MSVCRT_EINVAL;
1852 }
1853
1854 if( digits<0 || digits>=size) {
1855 if(size)
1856 buff[0] = '\0';
1857
1858 *MSVCRT__errno() = MSVCRT_ERANGE;
1859 return MSVCRT_ERANGE;
1860 }
1861
1862 len = MSVCRT__scprintf("%.*g", digits, number);
1863 if(len > size) {
1864 buff[0] = '\0';
1865 *MSVCRT__errno() = MSVCRT_ERANGE;
1866 return MSVCRT_ERANGE;
1867 }
1868
1869 MSVCRT_sprintf(buff, "%.*g", digits, number);
1870 return 0;
1871 }
1872
1873 #include <stdlib.h> /* div_t, ldiv_t */
1874
1875 /*********************************************************************
1876 * div (MSVCRT.@)
1877 * VERSION
1878 * [i386] Windows binary compatible - returns the struct in eax/edx.
1879 */
1880 #ifdef __i386__
1881 unsigned __int64 CDECL MSVCRT_div(int num, int denom)
1882 {
1883 div_t dt = div(num,denom);
1884 return ((unsigned __int64)dt.rem << 32) | (unsigned int)dt.quot;
1885 }
1886 #else
1887 /*********************************************************************
1888 * div (MSVCRT.@)
1889 * VERSION
1890 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1891 */
1892 MSVCRT_div_t CDECL MSVCRT_div(int num, int denom)
1893 {
1894 div_t dt = div(num,denom);
1895 MSVCRT_div_t ret;
1896 ret.quot = dt.quot;
1897 ret.rem = dt.rem;
1898
1899 return ret;
1900
1901 }
1902 #endif /* ifdef __i386__ */
1903
1904
1905 /*********************************************************************
1906 * ldiv (MSVCRT.@)
1907 * VERSION
1908 * [i386] Windows binary compatible - returns the struct in eax/edx.
1909 */
1910 #ifdef __i386__
1911 unsigned __int64 CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1912 {
1913 ldiv_t ldt = ldiv(num,denom);
1914 return ((unsigned __int64)ldt.rem << 32) | (MSVCRT_ulong)ldt.quot;
1915 }
1916 #else
1917 /*********************************************************************
1918 * ldiv (MSVCRT.@)
1919 * VERSION
1920 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1921 */
1922 MSVCRT_ldiv_t CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1923 {
1924 ldiv_t result = ldiv(num,denom);
1925
1926 MSVCRT_ldiv_t ret;
1927 ret.quot = result.quot;
1928 ret.rem = result.rem;
1929
1930 return ret;
1931 }
1932 #endif /* ifdef __i386__ */
1933
1934 /*********************************************************************
1935 * lldiv (MSVCRT.@)
1936 */
1937 MSVCRT_lldiv_t CDECL MSVCRT_lldiv(MSVCRT_longlong num, MSVCRT_longlong denom)
1938 {
1939 MSVCRT_lldiv_t ret;
1940
1941 ret.quot = num / denom;
1942 ret.rem = num % denom;
1943
1944 return ret;
1945 }
1946
1947 #ifdef __i386__
1948
1949 /*********************************************************************
1950 * _adjust_fdiv (MSVCRT.@)
1951 * Used by the MSVC compiler to work around the Pentium FDIV bug.
1952 */
1953 int MSVCRT__adjust_fdiv = 0;
1954
1955 /***********************************************************************
1956 * _adj_fdiv_m16i (MSVCRT.@)
1957 *
1958 * NOTE
1959 * I _think_ this function is intended to work around the Pentium
1960 * fdiv bug.
1961 */
1962 void __stdcall _adj_fdiv_m16i( short arg )
1963 {
1964 TRACE("(): stub\n");
1965 }
1966
1967 /***********************************************************************
1968 * _adj_fdiv_m32 (MSVCRT.@)
1969 *
1970 * NOTE
1971 * I _think_ this function is intended to work around the Pentium
1972 * fdiv bug.
1973 */
1974 void __stdcall _adj_fdiv_m32( unsigned int arg )
1975 {
1976 TRACE("(): stub\n");
1977 }
1978
1979 /***********************************************************************
1980 * _adj_fdiv_m32i (MSVCRT.@)
1981 *
1982 * NOTE
1983 * I _think_ this function is intended to work around the Pentium
1984 * fdiv bug.
1985 */
1986 void __stdcall _adj_fdiv_m32i( int arg )
1987 {
1988 TRACE("(): stub\n");
1989 }
1990
1991 /***********************************************************************
1992 * _adj_fdiv_m64 (MSVCRT.@)
1993 *
1994 * NOTE
1995 * I _think_ this function is intended to work around the Pentium
1996 * fdiv bug.
1997 */
1998 void __stdcall _adj_fdiv_m64( unsigned __int64 arg )
1999 {
2000 TRACE("(): stub\n");
2001 }
2002
2003 /***********************************************************************
2004 * _adj_fdiv_r (MSVCRT.@)
2005 * FIXME
2006 * This function is likely to have the wrong number of arguments.
2007 *
2008 * NOTE
2009 * I _think_ this function is intended to work around the Pentium
2010 * fdiv bug.
2011 */
2012 void _adj_fdiv_r(void)
2013 {
2014 TRACE("(): stub\n");
2015 }
2016
2017 /***********************************************************************
2018 * _adj_fdivr_m16i (MSVCRT.@)
2019 *
2020 * NOTE
2021 * I _think_ this function is intended to work around the Pentium
2022 * fdiv bug.
2023 */
2024 void __stdcall _adj_fdivr_m16i( short arg )
2025 {
2026 TRACE("(): stub\n");
2027 }
2028
2029 /***********************************************************************
2030 * _adj_fdivr_m32 (MSVCRT.@)
2031 *
2032 * NOTE
2033 * I _think_ this function is intended to work around the Pentium
2034 * fdiv bug.
2035 */
2036 void __stdcall _adj_fdivr_m32( unsigned int arg )
2037 {
2038 TRACE("(): stub\n");
2039 }
2040
2041 /***********************************************************************
2042 * _adj_fdivr_m32i (MSVCRT.@)
2043 *
2044 * NOTE
2045 * I _think_ this function is intended to work around the Pentium
2046 * fdiv bug.
2047 */
2048 void __stdcall _adj_fdivr_m32i( int arg )
2049 {
2050 TRACE("(): stub\n");
2051 }
2052
2053 /***********************************************************************
2054 * _adj_fdivr_m64 (MSVCRT.@)
2055 *
2056 * NOTE
2057 * I _think_ this function is intended to work around the Pentium
2058 * fdiv bug.
2059 */
2060 void __stdcall _adj_fdivr_m64( unsigned __int64 arg )
2061 {
2062 TRACE("(): stub\n");
2063 }
2064
2065 /***********************************************************************
2066 * _adj_fpatan (MSVCRT.@)
2067 * FIXME
2068 * This function is likely to have the wrong number of arguments.
2069 *
2070 * NOTE
2071 * I _think_ this function is intended to work around the Pentium
2072 * fdiv bug.
2073 */
2074 void _adj_fpatan(void)
2075 {
2076 TRACE("(): stub\n");
2077 }
2078
2079 /***********************************************************************
2080 * _adj_fprem (MSVCRT.@)
2081 * FIXME
2082 * This function is likely to have the wrong number of arguments.
2083 *
2084 * NOTE
2085 * I _think_ this function is intended to work around the Pentium
2086 * fdiv bug.
2087 */
2088 void _adj_fprem(void)
2089 {
2090 TRACE("(): stub\n");
2091 }
2092
2093 /***********************************************************************
2094 * _adj_fprem1 (MSVCRT.@)
2095 * FIXME
2096 * This function is likely to have the wrong number of arguments.
2097 *
2098 * NOTE
2099 * I _think_ this function is intended to work around the Pentium
2100 * fdiv bug.
2101 */
2102 void _adj_fprem1(void)
2103 {
2104 TRACE("(): stub\n");
2105 }
2106
2107 /***********************************************************************
2108 * _adj_fptan (MSVCRT.@)
2109 * FIXME
2110 * This function is likely to have the wrong number of arguments.
2111 *
2112 * NOTE
2113 * I _think_ this function is intended to work around the Pentium
2114 * fdiv bug.
2115 */
2116 void _adj_fptan(void)
2117 {
2118 TRACE("(): stub\n");
2119 }
2120
2121 /***********************************************************************
2122 * _safe_fdiv (MSVCRT.@)
2123 * FIXME
2124 * This function is likely to have the wrong number of arguments.
2125 *
2126 * NOTE
2127 * I _think_ this function is intended to work around the Pentium
2128 * fdiv bug.
2129 */
2130 void _safe_fdiv(void)
2131 {
2132 TRACE("(): stub\n");
2133 }
2134
2135 /***********************************************************************
2136 * _safe_fdivr (MSVCRT.@)
2137 * FIXME
2138 * This function is likely to have the wrong number of arguments.
2139 *
2140 * NOTE
2141 * I _think_ this function is intended to work around the Pentium
2142 * fdiv bug.
2143 */
2144 void _safe_fdivr(void)
2145 {
2146 TRACE("(): stub\n");
2147 }
2148
2149 /***********************************************************************
2150 * _safe_fprem (MSVCRT.@)
2151 * FIXME
2152 * This function is likely to have the wrong number of arguments.
2153 *
2154 * NOTE
2155 * I _think_ this function is intended to work around the Pentium
2156 * fdiv bug.
2157 */
2158 void _safe_fprem(void)
2159 {
2160 TRACE("(): stub\n");
2161 }
2162
2163 /***********************************************************************
2164 * _safe_fprem1 (MSVCRT.@)
2165 *
2166 * FIXME
2167 * This function is likely to have the wrong number of arguments.
2168 *
2169 * NOTE
2170 * I _think_ this function is intended to work around the Pentium
2171 * fdiv bug.
2172 */
2173 void _safe_fprem1(void)
2174 {
2175 TRACE("(): stub\n");
2176 }
2177
2178 /***********************************************************************
2179 * __libm_sse2_acos (MSVCRT.@)
2180 */
2181 void __cdecl MSVCRT___libm_sse2_acos(void)
2182 {
2183 double d;
2184 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2185 d = acos( d );
2186 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2187 }
2188
2189 /***********************************************************************
2190 * __libm_sse2_acosf (MSVCRT.@)
2191 */
2192 void __cdecl MSVCRT___libm_sse2_acosf(void)
2193 {
2194 float f;
2195 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2196 f = acosf( f );
2197 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2198 }
2199
2200 /***********************************************************************
2201 * __libm_sse2_asin (MSVCRT.@)
2202 */
2203 void __cdecl MSVCRT___libm_sse2_asin(void)
2204 {
2205 double d;
2206 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2207 d = asin( d );
2208 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2209 }
2210
2211 /***********************************************************************
2212 * __libm_sse2_asinf (MSVCRT.@)
2213 */
2214 void __cdecl MSVCRT___libm_sse2_asinf(void)
2215 {
2216 float f;
2217 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2218 f = asinf( f );
2219 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2220 }
2221
2222 /***********************************************************************
2223 * __libm_sse2_atan (MSVCRT.@)
2224 */
2225 void __cdecl MSVCRT___libm_sse2_atan(void)
2226 {
2227 double d;
2228 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2229 d = atan( d );
2230 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2231 }
2232
2233 /***********************************************************************
2234 * __libm_sse2_atan2 (MSVCRT.@)
2235 */
2236 void __cdecl MSVCRT___libm_sse2_atan2(void)
2237 {
2238 double d1, d2;
2239 __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2240 d1 = atan2( d1, d2 );
2241 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2242 }
2243
2244 /***********************************************************************
2245 * __libm_sse2_atanf (MSVCRT.@)
2246 */
2247 void __cdecl MSVCRT___libm_sse2_atanf(void)
2248 {
2249 float f;
2250 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2251 f = atanf( f );
2252 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2253 }
2254
2255 /***********************************************************************
2256 * __libm_sse2_cos (MSVCRT.@)
2257 */
2258 void __cdecl MSVCRT___libm_sse2_cos(void)
2259 {
2260 double d;
2261 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2262 d = cos( d );
2263 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2264 }
2265
2266 /***********************************************************************
2267 * __libm_sse2_cosf (MSVCRT.@)
2268 */
2269 void __cdecl MSVCRT___libm_sse2_cosf(void)
2270 {
2271 float f;
2272 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2273 f = cosf( f );
2274 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2275 }
2276
2277 /***********************************************************************
2278 * __libm_sse2_exp (MSVCRT.@)
2279 */
2280 void __cdecl MSVCRT___libm_sse2_exp(void)
2281 {
2282 double d;
2283 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2284 d = exp( d );
2285 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2286 }
2287
2288 /***********************************************************************
2289 * __libm_sse2_expf (MSVCRT.@)
2290 */
2291 void __cdecl MSVCRT___libm_sse2_expf(void)
2292 {
2293 float f;
2294 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2295 f = expf( f );
2296 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2297 }
2298
2299 /***********************************************************************
2300 * __libm_sse2_log (MSVCRT.@)
2301 */
2302 void __cdecl MSVCRT___libm_sse2_log(void)
2303 {
2304 double d;
2305 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2306 d = log( d );
2307 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2308 }
2309
2310 /***********************************************************************
2311 * __libm_sse2_log10 (MSVCRT.@)
2312 */
2313 void __cdecl MSVCRT___libm_sse2_log10(void)
2314 {
2315 double d;
2316 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2317 d = log10( d );
2318 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2319 }
2320
2321 /***********************************************************************
2322 * __libm_sse2_log10f (MSVCRT.@)
2323 */
2324 void __cdecl MSVCRT___libm_sse2_log10f(void)
2325 {
2326 float f;
2327 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2328 f = log10f( f );
2329 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2330 }
2331
2332 /***********************************************************************
2333 * __libm_sse2_logf (MSVCRT.@)
2334 */
2335 void __cdecl MSVCRT___libm_sse2_logf(void)
2336 {
2337 float f;
2338 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2339 f = logf( f );
2340 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2341 }
2342
2343 /***********************************************************************
2344 * __libm_sse2_pow (MSVCRT.@)
2345 */
2346 void __cdecl MSVCRT___libm_sse2_pow(void)
2347 {
2348 double d1, d2;
2349 __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2350 d1 = pow( d1, d2 );
2351 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2352 }
2353
2354 /***********************************************************************
2355 * __libm_sse2_powf (MSVCRT.@)
2356 */
2357 void __cdecl MSVCRT___libm_sse2_powf(void)
2358 {
2359 float f1, f2;
2360 __asm__ __volatile__( "movd %%xmm0,%0; movd %%xmm1,%1" : "=g" (f1), "=g" (f2) );
2361 f1 = powf( f1, f2 );
2362 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f1) );
2363 }
2364
2365 /***********************************************************************
2366 * __libm_sse2_sin (MSVCRT.@)
2367 */
2368 void __cdecl MSVCRT___libm_sse2_sin(void)
2369 {
2370 double d;
2371 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2372 d = sin( d );
2373 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2374 }
2375
2376 /***********************************************************************
2377 * __libm_sse2_sinf (MSVCRT.@)
2378 */
2379 void __cdecl MSVCRT___libm_sse2_sinf(void)
2380 {
2381 float f;
2382 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2383 f = sinf( f );
2384 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2385 }
2386
2387 /***********************************************************************
2388 * __libm_sse2_tan (MSVCRT.@)
2389 */
2390 void __cdecl MSVCRT___libm_sse2_tan(void)
2391 {
2392 double d;
2393 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2394 d = tan( d );
2395 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2396 }
2397
2398 /***********************************************************************
2399 * __libm_sse2_tanf (MSVCRT.@)
2400 */
2401 void __cdecl MSVCRT___libm_sse2_tanf(void)
2402 {
2403 float f;
2404 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2405 f = tanf( f );
2406 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2407 }
2408
2409 /***********************************************************************
2410 * __libm_sse2_sqrt_precise (MSVCR110.@)
2411 */
2412 void __cdecl MSVCRT___libm_sse2_sqrt_precise(void)
2413 {
2414 double d;
2415 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2416 d = sqrt( d );
2417 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2418 }
2419
2420 #endif /* __i386__ */
2421
2422 /*********************************************************************
2423 * cbrt (MSVCR120.@)
2424 */
2425 double CDECL MSVCR120_cbrt(double x)
2426 {
2427 #ifdef HAVE_CBRT
2428 return cbrt(x);
2429 #else
2430 return x < 0 ? -pow(-x, 1.0 / 3.0) : pow(x, 1.0 / 3.0);
2431 #endif
2432 }
2433
2434 /*********************************************************************
2435 * cbrtf (MSVCR120.@)
2436 */
2437 float CDECL MSVCR120_cbrtf(float x)
2438 {
2439 #ifdef HAVE_CBRTF
2440 return cbrtf(x);
2441 #else
2442 return MSVCR120_cbrt(x);
2443 #endif
2444 }
2445
2446 /*********************************************************************
2447 * cbrtl (MSVCR120.@)
2448 */
2449 LDOUBLE CDECL MSVCR120_cbrtl(LDOUBLE x)
2450 {
2451 return MSVCR120_cbrt(x);
2452 }
2453
2454 /*********************************************************************
2455 * exp2 (MSVCR120.@)
2456 */
2457 double CDECL MSVCR120_exp2(double x)
2458 {
2459 #ifdef HAVE_EXP2
2460 double ret = exp2(x);
2461 #else
2462 double ret = pow(2, x);
2463 #endif
2464 if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
2465 return ret;
2466 }
2467
2468 /*********************************************************************
2469 * exp2f (MSVCR120.@)
2470 */
2471 float CDECL MSVCR120_exp2f(float x)
2472 {
2473 #ifdef HAVE_EXP2F
2474 float ret = exp2f(x);
2475 if (finitef(x) && !finitef(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
2476 return ret;
2477 #else
2478 return MSVCR120_exp2(x);
2479 #endif
2480 }
2481
2482 /*********************************************************************
2483 * exp2l (MSVCR120.@)
2484 */
2485 LDOUBLE CDECL MSVCR120_exp2l(LDOUBLE x)
2486 {
2487 return MSVCR120_exp2(x);
2488 }
2489
2490 /*********************************************************************
2491 * expm1 (MSVCR120.@)
2492 */
2493 double CDECL MSVCR120_expm1(double x)
2494 {
2495 #ifdef HAVE_EXPM1
2496 double ret = expm1(x);
2497 #else
2498 double ret = exp(x) - 1;
2499 #endif
2500 if (isfinite(x) && !isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
2501 return ret;
2502 }
2503
2504 /*********************************************************************
2505 * expm1f (MSVCR120.@)
2506 */
2507 float CDECL MSVCR120_expm1f(float x)
2508 {
2509 #ifdef HAVE_EXPM1F
2510 float ret = expm1f(x);
2511 #else
2512 float ret = exp(x) - 1;
2513 #endif
2514 if (finitef(x) && !finitef(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
2515 return ret;
2516 }
2517
2518 /*********************************************************************
2519 * expm1l (MSVCR120.@)
2520 */
2521 LDOUBLE CDECL MSVCR120_expm1l(LDOUBLE x)
2522 {
2523 return MSVCR120_expm1(x);
2524 }
2525
2526 /*********************************************************************
2527 * log1p (MSVCR120.@)
2528 */
2529 double CDECL MSVCR120_log1p(double x)
2530 {
2531 if (x < -1) *MSVCRT__errno() = MSVCRT_EDOM;
2532 else if (x == -1) *MSVCRT__errno() = MSVCRT_ERANGE;
2533 #ifdef HAVE_LOG1P
2534 return log1p(x);
2535 #else
2536 return log(1 + x);
2537 #endif
2538 }
2539
2540 /*********************************************************************
2541 * log1pf (MSVCR120.@)
2542 */
2543 float CDECL MSVCR120_log1pf(float x)
2544 {
2545 if (x < -1) *MSVCRT__errno() = MSVCRT_EDOM;
2546 else if (x == -1) *MSVCRT__errno() = MSVCRT_ERANGE;
2547 #ifdef HAVE_LOG1PF
2548 return log1pf(x);
2549 #else
2550 return log(1 + x);
2551 #endif
2552 }
2553
2554 /*********************************************************************
2555 * log1pl (MSVCR120.@)
2556 */
2557 LDOUBLE CDECL MSVCR120_log1pl(LDOUBLE x)
2558 {
2559 return MSVCR120_log1p(x);
2560 }
2561
2562 /*********************************************************************
2563 * log2 (MSVCR120.@)
2564 */
2565 double CDECL MSVCR120_log2(double x)
2566 {
2567 if (x < 0) *MSVCRT__errno() = MSVCRT_EDOM;
2568 else if (x == 0) *MSVCRT__errno() = MSVCRT_ERANGE;
2569 #ifdef HAVE_LOG2
2570 return log2(x);
2571 #else
2572 return log(x) / log(2);
2573 #endif
2574 }
2575
2576 /*********************************************************************
2577 * log2f (MSVCR120.@)
2578 */
2579 float CDECL MSVCR120_log2f(float x)
2580 {
2581 #ifdef HAVE_LOG2F
2582 if (x < 0) *MSVCRT__errno() = MSVCRT_EDOM;
2583 else if (x == 0) *MSVCRT__errno() = MSVCRT_ERANGE;
2584 return log2f(x);
2585 #else
2586 return MSVCR120_log2(x);
2587 #endif
2588 }
2589
2590 /*********************************************************************
2591 * log2l (MSVCR120.@)
2592 */
2593 LDOUBLE CDECL MSVCR120_log2l(LDOUBLE x)
2594 {
2595 return MSVCR120_log2(x);
2596 }
2597
2598 /*********************************************************************
2599 * rint (MSVCR120.@)
2600 */
2601 double CDECL MSVCR120_rint(double x)
2602 {
2603 #ifdef HAVE_RINT
2604 return rint(x);
2605 #else
2606 return x >= 0 ? floor(x + 0.5) : ceil(x - 0.5);
2607 #endif
2608 }
2609
2610 /*********************************************************************
2611 * rintf (MSVCR120.@)
2612 */
2613 float CDECL MSVCR120_rintf(float x)
2614 {
2615 #ifdef HAVE_RINTF
2616 return rintf(x);
2617 #else
2618 return MSVCR120_rint(x);
2619 #endif
2620 }
2621
2622 /*********************************************************************
2623 * rintl (MSVCR120.@)
2624 */
2625 LDOUBLE CDECL MSVCR120_rintl(LDOUBLE x)
2626 {
2627 return MSVCR120_rint(x);
2628 }
2629
2630 /*********************************************************************
2631 * lrint (MSVCR120.@)
2632 */
2633 MSVCRT_long CDECL MSVCR120_lrint(double x)
2634 {
2635 #ifdef HAVE_LRINT
2636 return lrint(x);
2637 #else
2638 return MSVCR120_rint(x);
2639 #endif
2640 }
2641
2642 /*********************************************************************
2643 * lrintf (MSVCR120.@)
2644 */
2645 MSVCRT_long CDECL MSVCR120_lrintf(float x)
2646 {
2647 #ifdef HAVE_LRINTF
2648 return lrintf(x);
2649 #else
2650 return MSVCR120_lrint(x);
2651 #endif
2652 }
2653
2654 /*********************************************************************
2655 * lrintl (MSVCR120.@)
2656 */
2657 MSVCRT_long CDECL MSVCR120_lrintl(LDOUBLE x)
2658 {
2659 return MSVCR120_lrint(x);
2660 }
2661
2662 /*********************************************************************
2663 * llrint (MSVCR120.@)
2664 */
2665 MSVCRT_longlong CDECL MSVCR120_llrint(double x)
2666 {
2667 #ifdef HAVE_LLRINT
2668 return llrint(x);
2669 #else
2670 return MSVCR120_rint(x);
2671 #endif
2672 }
2673
2674 /*********************************************************************
2675 * llrintf (MSVCR120.@)
2676 */
2677 MSVCRT_longlong CDECL MSVCR120_llrintf(float x)
2678 {
2679 #ifdef HAVE_LLRINTF
2680 return llrintf(x);
2681 #else
2682 return MSVCR120_llrint(x);
2683 #endif
2684 }
2685
2686 /*********************************************************************
2687 * rintl (MSVCR120.@)
2688 */
2689 MSVCRT_longlong CDECL MSVCR120_llrintl(LDOUBLE x)
2690 {
2691 return MSVCR120_llrint(x);
2692 }
2693
2694 /*********************************************************************
2695 * round (MSVCR120.@)
2696 */
2697 double CDECL MSVCR120_round(double x)
2698 {
2699 #ifdef HAVE_ROUND
2700 return round(x);
2701 #else
2702 return MSVCR120_rint(x);
2703 #endif
2704 }
2705
2706 /*********************************************************************
2707 * roundf (MSVCR120.@)
2708 */
2709 float CDECL MSVCR120_roundf(float x)
2710 {
2711 #ifdef HAVE_ROUNDF
2712 return roundf(x);
2713 #else
2714 return MSVCR120_round(x);
2715 #endif
2716 }
2717
2718 /*********************************************************************
2719 * roundl (MSVCR120.@)
2720 */
2721 LDOUBLE CDECL MSVCR120_roundl(LDOUBLE x)
2722 {
2723 return MSVCR120_round(x);
2724 }
2725
2726 /*********************************************************************
2727 * lround (MSVCR120.@)
2728 */
2729 MSVCRT_long CDECL MSVCR120_lround(double x)
2730 {
2731 #ifdef HAVE_LROUND
2732 return lround(x);
2733 #else
2734 return MSVCR120_round(x);
2735 #endif
2736 }
2737
2738 /*********************************************************************
2739 * lroundf (MSVCR120.@)
2740 */
2741 MSVCRT_long CDECL MSVCR120_lroundf(float x)
2742 {
2743 #ifdef HAVE_LROUNDF
2744 return lroundf(x);
2745 #else
2746 return MSVCR120_lround(x);
2747 #endif
2748 }
2749
2750 /*********************************************************************
2751 * lroundl (MSVCR120.@)
2752 */
2753 MSVCRT_long CDECL MSVCR120_lroundl(LDOUBLE x)
2754 {
2755 return MSVCR120_lround(x);
2756 }
2757
2758 /*********************************************************************
2759 * llround (MSVCR120.@)
2760 */
2761 MSVCRT_longlong CDECL MSVCR120_llround(double x)
2762 {
2763 #ifdef HAVE_LLROUND
2764 return llround(x);
2765 #else
2766 return MSVCR120_round(x);
2767 #endif
2768 }
2769
2770 /*********************************************************************
2771 * llroundf (MSVCR120.@)
2772 */
2773 MSVCRT_longlong CDECL MSVCR120_llroundf(float x)
2774 {
2775 #ifdef HAVE_LLROUNDF
2776 return llroundf(x);
2777 #else
2778 return MSVCR120_llround(x);
2779 #endif
2780 }
2781
2782 /*********************************************************************
2783 * roundl (MSVCR120.@)
2784 */
2785 MSVCRT_longlong CDECL MSVCR120_llroundl(LDOUBLE x)
2786 {
2787 return MSVCR120_llround(x);
2788 }
2789
2790 /*********************************************************************
2791 * trunc (MSVCR120.@)
2792 */
2793 double CDECL MSVCR120_trunc(double x)
2794 {
2795 #ifdef HAVE_TRUNC
2796 return trunc(x);
2797 #else
2798 return (x > 0) ? floor(x) : ceil(x);
2799 #endif
2800 }
2801
2802 /*********************************************************************
2803 * truncf (MSVCR120.@)
2804 */
2805 float CDECL MSVCR120_truncf(float x)
2806 {
2807 #ifdef HAVE_TRUNCF
2808 return truncf(x);
2809 #else
2810 return MSVCR120_trunc(x);
2811 #endif
2812 }
2813
2814 /*********************************************************************
2815 * truncl (MSVCR120.@)
2816 */
2817 LDOUBLE CDECL MSVCR120_truncl(LDOUBLE x)
2818 {
2819 return MSVCR120_trunc(x);
2820 }
2821
2822 /*********************************************************************
2823 * _dclass (MSVCR120.@)
2824 */
2825 short CDECL MSVCR120__dclass(double x)
2826 {
2827 switch (MSVCRT__fpclass(x)) {
2828 case MSVCRT__FPCLASS_QNAN:
2829 case MSVCRT__FPCLASS_SNAN:
2830 return MSVCRT_FP_NAN;
2831 case MSVCRT__FPCLASS_NINF:
2832 case MSVCRT__FPCLASS_PINF:
2833 return MSVCRT_FP_INFINITE;
2834 case MSVCRT__FPCLASS_ND:
2835 case MSVCRT__FPCLASS_PD:
2836 return MSVCRT_FP_SUBNORMAL;
2837 case MSVCRT__FPCLASS_NN:
2838 case MSVCRT__FPCLASS_PN:
2839 default:
2840 return MSVCRT_FP_NORMAL;
2841 case MSVCRT__FPCLASS_NZ:
2842 case MSVCRT__FPCLASS_PZ:
2843 return MSVCRT_FP_ZERO;
2844 }
2845 }
2846
2847 /*********************************************************************
2848 * _fdclass (MSVCR120.@)
2849 */
2850 short CDECL MSVCR120__fdclass(float x)
2851 {
2852 return MSVCR120__dclass(x);
2853 }
2854
2855 /*********************************************************************
2856 * _ldclass (MSVCR120.@)
2857 */
2858 short CDECL MSVCR120__ldclass(LDOUBLE x)
2859 {
2860 return MSVCR120__dclass(x);
2861 }
2862
2863 /*********************************************************************
2864 * _dtest (MSVCR120.@)
2865 */
2866 short CDECL MSVCR120__dtest(double *x)
2867 {
2868 return MSVCR120__dclass(*x);
2869 }
2870
2871 /*********************************************************************
2872 * _fdtest (MSVCR120.@)
2873 */
2874 short CDECL MSVCR120__fdtest(float *x)
2875 {
2876 return MSVCR120__dclass(*x);
2877 }
2878
2879 /*********************************************************************
2880 * _ldtest (MSVCR120.@)
2881 */
2882 short CDECL MSVCR120__ldtest(LDOUBLE *x)
2883 {
2884 return MSVCR120__dclass(*x);
2885 }
2886
2887 /*********************************************************************
2888 * erf (MSVCR120.@)
2889 */
2890 double CDECL MSVCR120_erf(double x)
2891 {
2892 #ifdef HAVE_ERF
2893 return erf(x);
2894 #else
2895 /* Abramowitz and Stegun approximation, maximum error: 1.5*10^-7 */
2896 double t, y;
2897 int sign = signbit(x);
2898
2899 if (sign) x = -x;
2900 t = 1 / (1 + 0.3275911 * x);
2901 y = ((((1.061405429*t - 1.453152027)*t + 1.421413741)*t - 0.284496736)*t + 0.254829592)*t;
2902 y = 1.0 - y*exp(-x*x);
2903 return sign ? -y : y;
2904 #endif
2905 }
2906
2907 /*********************************************************************
2908 * erff (MSVCR120.@)
2909 */
2910 float CDECL MSVCR120_erff(float x)
2911 {
2912 #ifdef HAVE_ERFF
2913 return erff(x);
2914 #else
2915 return MSVCR120_erf(x);
2916 #endif
2917 }
2918
2919 /*********************************************************************
2920 * erfl (MSVCR120.@)
2921 */
2922 LDOUBLE CDECL MSVCR120_erfl(LDOUBLE x)
2923 {
2924 return MSVCR120_erf(x);
2925 }
2926
2927 /*********************************************************************
2928 * erfc (MSVCR120.@)
2929 */
2930 double CDECL MSVCR120_erfc(double x)
2931 {
2932 #ifdef HAVE_ERFC
2933 return erfc(x);
2934 #else
2935 return 1 - MSVCR120_erf(x);
2936 #endif
2937 }
2938
2939 /*********************************************************************
2940 * erfcf (MSVCR120.@)
2941 */
2942 float CDECL MSVCR120_erfcf(float x)
2943 {
2944 #ifdef HAVE_ERFCF
2945 return erfcf(x);
2946 #else
2947 return MSVCR120_erfc(x);
2948 #endif
2949 }
2950
2951 /*********************************************************************
2952 * erfcl (MSVCR120.@)
2953 */
2954 LDOUBLE CDECL MSVCR120_erfcl(LDOUBLE x)
2955 {
2956 return MSVCR120_erfc(x);
2957 }
2958
2959 /*********************************************************************
2960 * fmaxf (MSVCR120.@)
2961 */
2962 float CDECL MSVCR120_fmaxf(float x, float y)
2963 {
2964 if(isnanf(x))
2965 return y;
2966 if(isnanf(y))
2967 return x;
2968 if(x==0 && y==0)
2969 return signbit(x) ? y : x;
2970 return x<y ? y : x;
2971 }
2972
2973 /*********************************************************************
2974 * fmax (MSVCR120.@)
2975 */
2976 double CDECL MSVCR120_fmax(double x, double y)
2977 {
2978 if(isnan(x))
2979 return y;
2980 if(isnan(y))
2981 return x;
2982 if(x==0 && y==0)
2983 return signbit(x) ? y : x;
2984 return x<y ? y : x;
2985 }
2986
2987 /*********************************************************************
2988 * _fdsign (MSVCR120.@)
2989 */
2990 int CDECL MSVCR120__fdsign(float x)
2991 {
2992 return signbit(x) ? 0x8000 : 0;
2993 }
2994
2995 /*********************************************************************
2996 * _dsign (MSVCR120.@)
2997 */
2998 int CDECL MSVCR120__dsign(double x)
2999 {
3000 return signbit(x) ? 0x8000 : 0;
3001 }
3002
3003
3004 /*********************************************************************
3005 * _dpcomp (MSVCR120.@)
3006 */
3007 int CDECL MSVCR120__dpcomp(double x, double y)
3008 {
3009 if(isnan(x) || isnan(y))
3010 return 0;
3011
3012 if(x == y) return 2;
3013 return x < y ? 1 : 4;
3014 }
3015
3016 /*********************************************************************
3017 * _fdpcomp (MSVCR120.@)
3018 */
3019 int CDECL MSVCR120__fdpcomp(float x, float y)
3020 {
3021 return MSVCR120__dpcomp(x, y);
3022 }
3023
3024 /*********************************************************************
3025 * fminf (MSVCR120.@)
3026 */
3027 float CDECL MSVCR120_fminf(float x, float y)
3028 {
3029 if(isnanf(x))
3030 return y;
3031 if(isnanf(y))
3032 return x;
3033 if(x==0 && y==0)
3034 return signbit(x) ? x : y;
3035 return x<y ? x : y;
3036 }
3037
3038 /*********************************************************************
3039 * fmin (MSVCR120.@)
3040 */
3041 double CDECL MSVCR120_fmin(double x, double y)
3042 {
3043 if(isnan(x))
3044 return y;
3045 if(isnan(y))
3046 return x;
3047 if(x==0 && y==0)
3048 return signbit(x) ? x : y;
3049 return x<y ? x : y;
3050 }
3051
3052 /*********************************************************************
3053 * asinh (MSVCR120.@)
3054 */
3055 double CDECL MSVCR120_asinh(double x)
3056 {
3057 #ifdef HAVE_ASINH
3058 return asinh(x);
3059 #else
3060 if (!isfinite(x*x+1)) return log(2) + log(x);
3061 return log(x + sqrt(x*x+1));
3062 #endif
3063 }
3064
3065 /*********************************************************************
3066 * asinhf (MSVCR120.@)
3067 */
3068 float CDECL MSVCR120_asinhf(float x)
3069 {
3070 #ifdef HAVE_ASINHF
3071 return asinhf(x);
3072 #else
3073 return MSVCR120_asinh(x);
3074 #endif
3075 }
3076
3077 /*********************************************************************
3078 * asinhl (MSVCR120.@)
3079 */
3080 LDOUBLE CDECL MSVCR120_asinhl(LDOUBLE x)
3081 {
3082 return MSVCR120_asinh(x);
3083 }
3084
3085 /*********************************************************************
3086 * acosh (MSVCR120.@)
3087 */
3088 double CDECL MSVCR120_acosh(double x)
3089 {
3090 if (x < 1) *MSVCRT__errno() = MSVCRT_EDOM;
3091
3092 #ifdef HAVE_ACOSH
3093 return acosh(x);
3094 #else
3095 if (x < 1) {
3096 MSVCRT_fenv_t env;
3097
3098 MSVCRT_fegetenv(&env);
3099 env.status |= MSVCRT__SW_INVALID;
3100 MSVCRT_fesetenv(&env);
3101 return NAN;
3102 }
3103 if (!isfinite(x*x)) return log(2) + log(x);
3104 return log(x + sqrt(x*x-1));
3105 #endif
3106 }
3107
3108 /*********************************************************************
3109 * acoshf (MSVCR120.@)
3110 */
3111 float CDECL MSVCR120_acoshf(float x)
3112 {
3113 #ifdef HAVE_ACOSHF
3114 if (x < 1) *MSVCRT__errno() = MSVCRT_EDOM;
3115
3116 return acoshf(x);
3117 #else
3118 return MSVCR120_acosh(x);
3119 #endif
3120 }
3121
3122 /*********************************************************************
3123 * acoshl (MSVCR120.@)
3124 */
3125 LDOUBLE CDECL MSVCR120_acoshl(LDOUBLE x)
3126 {
3127 return MSVCR120_acosh(x);
3128 }
3129
3130 /*********************************************************************
3131 * atanh (MSVCR120.@)
3132 */
3133 double CDECL MSVCR120_atanh(double x)
3134 {
3135 double ret;
3136
3137 if (x > 1 || x < -1) {
3138 MSVCRT_fenv_t env;
3139
3140 *MSVCRT__errno() = MSVCRT_EDOM;
3141
3142 /* on Linux atanh returns -NAN in this case */
3143 MSVCRT_fegetenv(&env);
3144 env.status |= MSVCRT__SW_INVALID;
3145 MSVCRT_fesetenv(&env);
3146 return NAN;
3147 }
3148
3149 #ifdef HAVE_ATANH
3150 ret = atanh(x);
3151 #else
3152 if (-1e-6 < x && x < 1e-6) ret = x + x*x*x/3;
3153 else ret = (log(1+x) - log(1-x)) / 2;
3154 #endif
3155
3156 if (!isfinite(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
3157 return ret;
3158 }
3159
3160 /*********************************************************************
3161 * atanhf (MSVCR120.@)
3162 */
3163 float CDECL MSVCR120_atanhf(float x)
3164 {
3165 #ifdef HAVE_ATANHF
3166 float ret;
3167
3168 if (x > 1 || x < -1) {
3169 MSVCRT_fenv_t env;
3170
3171 *MSVCRT__errno() = MSVCRT_EDOM;
3172
3173 MSVCRT_fegetenv(&env);
3174 env.status |= MSVCRT__SW_INVALID;
3175 MSVCRT_fesetenv(&env);
3176 return NAN;
3177 }
3178
3179 ret = atanhf(x);
3180
3181 if (!finitef(ret)) *MSVCRT__errno() = MSVCRT_ERANGE;
3182 return ret;
3183 #else
3184 return MSVCR120_atanh(x);
3185 #endif
3186 }
3187
3188 /*********************************************************************
3189 * atanhl (MSVCR120.@)
3190 */
3191 LDOUBLE CDECL MSVCR120_atanhl(LDOUBLE x)
3192 {
3193 return MSVCR120_atanh(x);
3194 }
3195
3196 /*********************************************************************
3197 * _scalb (MSVCRT.@)
3198 * scalbn (MSVCR120.@)
3199 * scalbln (MSVCR120.@)
3200 */
3201 double CDECL MSVCRT__scalb(double num, MSVCRT_long power)
3202 {
3203 return MSVCRT_ldexp(num, power);
3204 }
3205
3206 /*********************************************************************
3207 * _scalbf (MSVCRT.@)
3208 * scalbnf (MSVCR120.@)
3209 * scalblnf (MSVCR120.@)
3210 */
3211 float CDECL MSVCRT__scalbf(float num, MSVCRT_long power)
3212 {
3213 return MSVCRT_ldexp(num, power);
3214 }
3215
3216 /*********************************************************************
3217 * scalbnl (MSVCR120.@)
3218 * scalblnl (MSVCR120.@)
3219 */
3220 LDOUBLE CDECL MSVCR120_scalbnl(LDOUBLE num, MSVCRT_long power)
3221 {
3222 return MSVCRT__scalb(num, power);
3223 }
3224
3225 /*********************************************************************
3226 * remainder (MSVCR120.@)
3227 */
3228 double CDECL MSVCR120_remainder(double x, double y)
3229 {
3230 #ifdef HAVE_REMAINDER
3231 /* this matches 64-bit Windows. 32-bit Windows is slightly different */
3232 if(!finite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
3233 if(isnan(y) || y==0.0) *MSVCRT__errno() = MSVCRT_EDOM;
3234 return remainder(x, y);
3235 #else
3236 FIXME( "not implemented\n" );
3237 return 0.0;
3238 #endif
3239 }
3240
3241 /*********************************************************************
3242 * remainderf (MSVCR120.@)
3243 */
3244 float CDECL MSVCR120_remainderf(float x, float y)
3245 {
3246 #ifdef HAVE_REMAINDERF
3247 /* this matches 64-bit Windows. 32-bit Windows is slightly different */
3248 if(!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
3249 if(isnanf(y) || y==0.0f) *MSVCRT__errno() = MSVCRT_EDOM;
3250 return remainderf(x, y);
3251 #else
3252 FIXME( "not implemented\n" );
3253 return 0.0f;
3254 #endif
3255 }
3256
3257 /*********************************************************************
3258 * remainderl (MSVCR120.@)
3259 */
3260 LDOUBLE CDECL MSVCR120_remainderl(LDOUBLE x, LDOUBLE y)
3261 {
3262 return MSVCR120_remainder(x, y);
3263 }
3264
3265 /*********************************************************************
3266 * lgamma (MSVCR120.@)
3267 */
3268 double CDECL MSVCR120_lgamma(double x)
3269 {
3270 #ifdef HAVE_LGAMMA
3271 return lgamma(x);
3272 #else
3273 FIXME( "not implemented\n" );
3274 return 0.0;
3275 #endif
3276 }
3277
3278 /*********************************************************************
3279 * lgammaf (MSVCR120.@)
3280 */
3281 float CDECL MSVCR120_lgammaf(float x)
3282 {
3283 #ifdef HAVE_LGAMMAF
3284 return lgammaf(x);
3285 #else
3286 FIXME( "not implemented\n" );
3287 return 0.0f;
3288 #endif
3289 }
3290
3291 /*********************************************************************
3292 * lgammal (MSVCR120.@)
3293 */
3294 LDOUBLE CDECL MSVCR120_lgammal(LDOUBLE x)
3295 {
3296 return MSVCR120_lgamma(x);
3297 }
3298
3299 /*********************************************************************
3300 * nan (MSVCR120.@)
3301 */
3302 double CDECL MSVCR120_nan(const char *tagp)
3303 {
3304 /* Windows ignores input (MSDN) */
3305 return NAN;
3306 }
3307
3308 /*********************************************************************
3309 * nanf (MSVCR120.@)
3310 */
3311 float CDECL MSVCR120_nanf(const char *tagp)
3312 {
3313 return NAN;
3314 }
3315
3316 /*********************************************************************
3317 * _except1 (MSVCR120.@)
3318 * TODO:
3319 * - find meaning of ignored cw and operation bits
3320 * - unk parameter
3321 */
3322 double CDECL _except1(DWORD fpe, _FP_OPERATION_CODE op, double arg, double res, DWORD cw, void *unk)
3323 {
3324 ULONG_PTR exception_arg;
3325 DWORD exception = 0;
3326 MSVCRT_fenv_t env;
3327 DWORD fpword = 0;
3328 WORD operation;
3329
3330 TRACE("(%x %x %lf %lf %x %p)\n", fpe, op, arg, res, cw, unk);
3331
3332 #ifdef _WIN64
3333 cw = ((cw >> 7) & 0x3f) | ((cw >> 3) & 0xc00);
3334 #endif
3335 operation = op << 5;
3336 exception_arg = (ULONG_PTR)&operation;
3337
3338 MSVCRT_fegetenv(&env);
3339
3340 if (fpe & 0x1) { /* overflow */
3341 if ((fpe == 0x1 && (cw & 0x8)) || (fpe==0x11 && (cw & 0x28))) {
3342 /* 32-bit version also sets SW_INEXACT here */
3343 env.status |= MSVCRT__SW_OVERFLOW;
3344 if (fpe & 0x10) env.status |= MSVCRT__SW_INEXACT;
3345 res = signbit(res) ? -INFINITY : INFINITY;
3346 } else {
3347 exception = EXCEPTION_FLT_OVERFLOW;
3348 }
3349 } else if (fpe & 0x2) { /* underflow */
3350 if ((fpe == 0x2 && (cw & 0x10)) || (fpe==0x12 && (cw & 0x30))) {
3351 env.status |= MSVCRT__SW_UNDERFLOW;
3352 if (fpe & 0x10) env.status |= MSVCRT__SW_INEXACT;
3353 res = signbit(res) ? -0.0 : 0.0;
3354 } else {
3355 exception = EXCEPTION_FLT_UNDERFLOW;
3356 }
3357 } else if (fpe & 0x4) { /* zerodivide */
3358 if ((fpe == 0x4 && (cw & 0x4)) || (fpe==0x14 && (cw & 0x24))) {
3359 env.status |= MSVCRT__SW_ZERODIVIDE;
3360 if (fpe & 0x10) env.status |= MSVCRT__SW_INEXACT;
3361 } else {
3362 exception = EXCEPTION_FLT_DIVIDE_BY_ZERO;
3363 }
3364 } else if (fpe & 0x8) { /* invalid */
3365 if (fpe == 0x8 && (cw & 0x1)) {
3366 env.status |= MSVCRT__SW_INVALID;
3367 } else {
3368 exception = EXCEPTION_FLT_INVALID_OPERATION;
3369 }
3370 } else if (fpe & 0x10) { /* inexact */
3371 if (fpe == 0x10 && (cw & 0x20)) {
3372 env.status |= MSVCRT__SW_INEXACT;
3373 } else {
3374 exception = EXCEPTION_FLT_INEXACT_RESULT;
3375 }
3376 }
3377
3378 if (exception)
3379 env.status = 0;
3380 MSVCRT_fesetenv(&env);
3381 if (exception)
3382 RaiseException(exception, 0, 1, &exception_arg);
3383
3384 if (cw & 0x1) fpword |= MSVCRT__EM_INVALID;
3385 if (cw & 0x2) fpword |= MSVCRT__EM_DENORMAL;
3386 if (cw & 0x4) fpword |= MSVCRT__EM_ZERODIVIDE;
3387 if (cw & 0x8) fpword |= MSVCRT__EM_OVERFLOW;
3388 if (cw & 0x10) fpword |= MSVCRT__EM_UNDERFLOW;
3389 if (cw & 0x20) fpword |= MSVCRT__EM_INEXACT;
3390 switch (cw & 0xc00)
3391 {
3392 case 0xc00: fpword |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
3393 case 0x800: fpword |= MSVCRT__RC_UP; break;
3394 case 0x400: fpword |= MSVCRT__RC_DOWN; break;
3395 }
3396 switch (cw & 0x300)
3397 {
3398 case 0x0: fpword |= MSVCRT__PC_24; break;
3399 case 0x200: fpword |= MSVCRT__PC_53; break;
3400 case 0x300: fpword |= MSVCRT__PC_64; break;
3401 }
3402 if (cw & 0x1000) fpword |= MSVCRT__IC_AFFINE;
3403 _control87(fpword, 0xffffffff);
3404
3405 return res;
3406 }
Windows API implementation