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