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