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