?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Support getdc with user memory.
[wine.git] / dlls / msvcrt / math.c
blob6bcc2b7db4f2a64650df5720c66939c594386f15
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 signbit
38 #define signbit(x) 0
39 #endif
40
41 typedef int (CDECL *MSVCRT_matherr_func)(struct MSVCRT__exception *);
42
43 static MSVCRT_matherr_func MSVCRT_default_matherr_func = NULL;
44
45 static BOOL sse2_supported;
46 static BOOL sse2_enabled;
47
48 void msvcrt_init_math(void)
49 {
50 sse2_supported = sse2_enabled = IsProcessorFeaturePresent( PF_XMMI64_INSTRUCTIONS_AVAILABLE );
51 }
52
53 /*********************************************************************
54 * _set_SSE2_enable (MSVCRT.@)
55 */
56 int CDECL MSVCRT__set_SSE2_enable(int flag)
57 {
58 sse2_enabled = flag && sse2_supported;
59 return sse2_enabled;
60 }
61
62 #if defined(__x86_64__) || defined(__arm__)
63
64 /*********************************************************************
65 * _chgsignf (MSVCRT.@)
66 */
67 float CDECL MSVCRT__chgsignf( float num )
68 {
69 /* FIXME: +-infinity,Nan not tested */
70 return -num;
71 }
72
73 /*********************************************************************
74 * _copysignf (MSVCRT.@)
75 */
76 float CDECL MSVCRT__copysignf( float num, float sign )
77 {
78 /* FIXME: Behaviour for Nan/Inf? */
79 if (sign < 0.0)
80 return num < 0.0 ? num : -num;
81 return num < 0.0 ? -num : num;
82 }
83
84 /*********************************************************************
85 * _finitef (MSVCRT.@)
86 */
87 int CDECL MSVCRT__finitef( float num )
88 {
89 return finitef(num) != 0; /* See comment for _isnan() */
90 }
91
92 /*********************************************************************
93 * _isnanf (MSVCRT.@)
94 */
95 INT CDECL MSVCRT__isnanf( float num )
96 {
97 /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
98 * Do the same, as the result may be used in calculations
99 */
100 return isnanf(num) != 0;
101 }
102
103 /*********************************************************************
104 * _logbf (MSVCRT.@)
105 */
106 float CDECL MSVCRT__logbf( float num )
107 {
108 if (!finitef(num)) *MSVCRT__errno() = MSVCRT_EDOM;
109 return logbf(num);
110 }
111
112 /*********************************************************************
113 * _nextafterf (MSVCRT.@)
114 */
115 float CDECL MSVCRT__nextafterf( float num, float next )
116 {
117 if (!finitef(num) || !finitef(next)) *MSVCRT__errno() = MSVCRT_EDOM;
118 return nextafterf( num, next );
119 }
120
121 /*********************************************************************
122 * MSVCRT_acosf (MSVCRT.@)
123 */
124 float CDECL MSVCRT_acosf( float x )
125 {
126 if (x < -1.0 || x > 1.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
127 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
128 * asin() uses a similar construction. This is bad because as x gets nearer to
129 * 1 the error in the expression "1 - x^2" can get relatively large due to
130 * cancellation. The sqrt() makes things worse. A safer way to calculate
131 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
132 return atan2f(sqrtf((1 - x) * (1 + x)), x);
133 }
134
135 /*********************************************************************
136 * MSVCRT_asinf (MSVCRT.@)
137 */
138 float CDECL MSVCRT_asinf( float x )
139 {
140 if (x < -1.0 || x > 1.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
141 return atan2f(x, sqrtf((1 - x) * (1 + x)));
142 }
143
144 /*********************************************************************
145 * MSVCRT_atanf (MSVCRT.@)
146 */
147 float CDECL MSVCRT_atanf( float x )
148 {
149 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
150 return atanf(x);
151 }
152
153 /*********************************************************************
154 * MSVCRT_atan2f (MSVCRT.@)
155 */
156 float CDECL MSVCRT_atan2f( float x, float y )
157 {
158 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
159 return atan2f(x,y);
160 }
161
162 /*********************************************************************
163 * MSVCRT_cosf (MSVCRT.@)
164 */
165 float CDECL MSVCRT_cosf( float x )
166 {
167 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
168 return cosf(x);
169 }
170
171 /*********************************************************************
172 * MSVCRT_coshf (MSVCRT.@)
173 */
174 float CDECL MSVCRT_coshf( float x )
175 {
176 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
177 return coshf(x);
178 }
179
180 /*********************************************************************
181 * MSVCRT_expf (MSVCRT.@)
182 */
183 float CDECL MSVCRT_expf( float x )
184 {
185 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
186 return expf(x);
187 }
188
189 /*********************************************************************
190 * MSVCRT_fmodf (MSVCRT.@)
191 */
192 float CDECL MSVCRT_fmodf( float x, float y )
193 {
194 if (!finitef(x) || !finitef(y)) *MSVCRT__errno() = MSVCRT_EDOM;
195 return fmodf(x,y);
196 }
197
198 /*********************************************************************
199 * MSVCRT_logf (MSVCRT.@)
200 */
201 float CDECL MSVCRT_logf( float x)
202 {
203 if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
204 if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
205 return logf(x);
206 }
207
208 /*********************************************************************
209 * MSVCRT_log10f (MSVCRT.@)
210 */
211 float CDECL MSVCRT_log10f( float x )
212 {
213 if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
214 if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
215 return log10f(x);
216 }
217
218 /*********************************************************************
219 * MSVCRT_powf (MSVCRT.@)
220 */
221 float CDECL MSVCRT_powf( float x, float y )
222 {
223 /* FIXME: If x < 0 and y is not integral, set EDOM */
224 float z = powf(x,y);
225 if (!finitef(z)) *MSVCRT__errno() = MSVCRT_EDOM;
226 return z;
227 }
228
229 /*********************************************************************
230 * MSVCRT_sinf (MSVCRT.@)
231 */
232 float CDECL MSVCRT_sinf( float x )
233 {
234 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
235 return sinf(x);
236 }
237
238 /*********************************************************************
239 * MSVCRT_sinhf (MSVCRT.@)
240 */
241 float CDECL MSVCRT_sinhf( float x )
242 {
243 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
244 return sinhf(x);
245 }
246
247 /*********************************************************************
248 * MSVCRT_sqrtf (MSVCRT.@)
249 */
250 float CDECL MSVCRT_sqrtf( float x )
251 {
252 if (x < 0.0 || !finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
253 return sqrtf(x);
254 }
255
256 /*********************************************************************
257 * MSVCRT_tanf (MSVCRT.@)
258 */
259 float CDECL MSVCRT_tanf( float x )
260 {
261 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
262 return tanf(x);
263 }
264
265 /*********************************************************************
266 * MSVCRT_tanhf (MSVCRT.@)
267 */
268 float CDECL MSVCRT_tanhf( float x )
269 {
270 if (!finitef(x)) *MSVCRT__errno() = MSVCRT_EDOM;
271 return tanhf(x);
272 }
273
274 /*********************************************************************
275 * ceilf (MSVCRT.@)
276 */
277 float CDECL MSVCRT_ceilf( float x )
278 {
279 return ceilf(x);
280 }
281
282 /*********************************************************************
283 * fabsf (MSVCRT.@)
284 */
285 float CDECL MSVCRT_fabsf( float x )
286 {
287 return fabsf(x);
288 }
289
290 /*********************************************************************
291 * floorf (MSVCRT.@)
292 */
293 float CDECL MSVCRT_floorf( float x )
294 {
295 return floorf(x);
296 }
297
298 /*********************************************************************
299 * frexpf (MSVCRT.@)
300 */
301 float CDECL MSVCRT_frexpf( float x, int *exp )
302 {
303 return frexpf( x, exp );
304 }
305
306 /*********************************************************************
307 * _scalbf (MSVCRT.@)
308 */
309 float CDECL MSVCRT__scalbf(float num, MSVCRT_long power)
310 {
311 if (!finitef(num)) *MSVCRT__errno() = MSVCRT_EDOM;
312 return ldexpf(num, power);
313 }
314
315 /*********************************************************************
316 * modff (MSVCRT.@)
317 */
318 double CDECL MSVCRT_modff( float x, float *iptr )
319 {
320 return modff( x, iptr );
321 }
322
323 #endif
324
325 /*********************************************************************
326 * MSVCRT_acos (MSVCRT.@)
327 */
328 double CDECL MSVCRT_acos( double x )
329 {
330 if (x < -1.0 || x > 1.0 || !isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
331 /* glibc implements acos() as the FPU equivalent of atan2(sqrt(1 - x ^ 2), x).
332 * asin() uses a similar construction. This is bad because as x gets nearer to
333 * 1 the error in the expression "1 - x^2" can get relatively large due to
334 * cancellation. The sqrt() makes things worse. A safer way to calculate
335 * acos() is to use atan2(sqrt((1 - x) * (1 + x)), x). */
336 return atan2(sqrt((1 - x) * (1 + x)), x);
337 }
338
339 /*********************************************************************
340 * MSVCRT_asin (MSVCRT.@)
341 */
342 double CDECL MSVCRT_asin( double x )
343 {
344 if (x < -1.0 || x > 1.0 || !isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
345 return atan2(x, sqrt((1 - x) * (1 + x)));
346 }
347
348 /*********************************************************************
349 * MSVCRT_atan (MSVCRT.@)
350 */
351 double CDECL MSVCRT_atan( double x )
352 {
353 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
354 return atan(x);
355 }
356
357 /*********************************************************************
358 * MSVCRT_atan2 (MSVCRT.@)
359 */
360 double CDECL MSVCRT_atan2( double x, double y )
361 {
362 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
363 return atan2(x,y);
364 }
365
366 /*********************************************************************
367 * MSVCRT_cos (MSVCRT.@)
368 */
369 double CDECL MSVCRT_cos( double x )
370 {
371 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
372 return cos(x);
373 }
374
375 /*********************************************************************
376 * MSVCRT_cosh (MSVCRT.@)
377 */
378 double CDECL MSVCRT_cosh( double x )
379 {
380 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
381 return cosh(x);
382 }
383
384 /*********************************************************************
385 * MSVCRT_exp (MSVCRT.@)
386 */
387 double CDECL MSVCRT_exp( double x )
388 {
389 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
390 return exp(x);
391 }
392
393 /*********************************************************************
394 * MSVCRT_fmod (MSVCRT.@)
395 */
396 double CDECL MSVCRT_fmod( double x, double y )
397 {
398 if (!isfinite(x) || !isfinite(y)) *MSVCRT__errno() = MSVCRT_EDOM;
399 return fmod(x,y);
400 }
401
402 /*********************************************************************
403 * MSVCRT_log (MSVCRT.@)
404 */
405 double CDECL MSVCRT_log( double x)
406 {
407 if (x < 0.0 || !isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
408 if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
409 return log(x);
410 }
411
412 /*********************************************************************
413 * MSVCRT_log10 (MSVCRT.@)
414 */
415 double CDECL MSVCRT_log10( double x )
416 {
417 if (x < 0.0 || !isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
418 if (x == 0.0) *MSVCRT__errno() = MSVCRT_ERANGE;
419 return log10(x);
420 }
421
422 /*********************************************************************
423 * MSVCRT_pow (MSVCRT.@)
424 */
425 double CDECL MSVCRT_pow( double x, double y )
426 {
427 /* FIXME: If x < 0 and y is not integral, set EDOM */
428 double z = pow(x,y);
429 if (!isfinite(z)) *MSVCRT__errno() = MSVCRT_EDOM;
430 return z;
431 }
432
433 /*********************************************************************
434 * MSVCRT_sin (MSVCRT.@)
435 */
436 double CDECL MSVCRT_sin( double x )
437 {
438 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
439 return sin(x);
440 }
441
442 /*********************************************************************
443 * MSVCRT_sinh (MSVCRT.@)
444 */
445 double CDECL MSVCRT_sinh( double x )
446 {
447 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
448 return sinh(x);
449 }
450
451 /*********************************************************************
452 * MSVCRT_sqrt (MSVCRT.@)
453 */
454 double CDECL MSVCRT_sqrt( double x )
455 {
456 if (x < 0.0 || !isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
457 return sqrt(x);
458 }
459
460 /*********************************************************************
461 * MSVCRT_tan (MSVCRT.@)
462 */
463 double CDECL MSVCRT_tan( double x )
464 {
465 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
466 return tan(x);
467 }
468
469 /*********************************************************************
470 * MSVCRT_tanh (MSVCRT.@)
471 */
472 double CDECL MSVCRT_tanh( double x )
473 {
474 if (!isfinite(x)) *MSVCRT__errno() = MSVCRT_EDOM;
475 return tanh(x);
476 }
477
478
479 #if defined(__GNUC__) && defined(__i386__)
480
481 #define FPU_DOUBLE(var) double var; \
482 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var) : )
483 #define FPU_DOUBLES(var1,var2) double var1,var2; \
484 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var2) : ); \
485 __asm__ __volatile__( "fstpl %0;fwait" : "=m" (var1) : )
486
487 /*********************************************************************
488 * _CIacos (MSVCRT.@)
489 */
490 double CDECL _CIacos(void)
491 {
492 FPU_DOUBLE(x);
493 return MSVCRT_acos(x);
494 }
495
496 /*********************************************************************
497 * _CIasin (MSVCRT.@)
498 */
499 double CDECL _CIasin(void)
500 {
501 FPU_DOUBLE(x);
502 return MSVCRT_asin(x);
503 }
504
505 /*********************************************************************
506 * _CIatan (MSVCRT.@)
507 */
508 double CDECL _CIatan(void)
509 {
510 FPU_DOUBLE(x);
511 return MSVCRT_atan(x);
512 }
513
514 /*********************************************************************
515 * _CIatan2 (MSVCRT.@)
516 */
517 double CDECL _CIatan2(void)
518 {
519 FPU_DOUBLES(x,y);
520 return MSVCRT_atan2(x,y);
521 }
522
523 /*********************************************************************
524 * _CIcos (MSVCRT.@)
525 */
526 double CDECL _CIcos(void)
527 {
528 FPU_DOUBLE(x);
529 return MSVCRT_cos(x);
530 }
531
532 /*********************************************************************
533 * _CIcosh (MSVCRT.@)
534 */
535 double CDECL _CIcosh(void)
536 {
537 FPU_DOUBLE(x);
538 return MSVCRT_cosh(x);
539 }
540
541 /*********************************************************************
542 * _CIexp (MSVCRT.@)
543 */
544 double CDECL _CIexp(void)
545 {
546 FPU_DOUBLE(x);
547 return MSVCRT_exp(x);
548 }
549
550 /*********************************************************************
551 * _CIfmod (MSVCRT.@)
552 */
553 double CDECL _CIfmod(void)
554 {
555 FPU_DOUBLES(x,y);
556 return MSVCRT_fmod(x,y);
557 }
558
559 /*********************************************************************
560 * _CIlog (MSVCRT.@)
561 */
562 double CDECL _CIlog(void)
563 {
564 FPU_DOUBLE(x);
565 return MSVCRT_log(x);
566 }
567
568 /*********************************************************************
569 * _CIlog10 (MSVCRT.@)
570 */
571 double CDECL _CIlog10(void)
572 {
573 FPU_DOUBLE(x);
574 return MSVCRT_log10(x);
575 }
576
577 /*********************************************************************
578 * _CIpow (MSVCRT.@)
579 */
580 double CDECL _CIpow(void)
581 {
582 FPU_DOUBLES(x,y);
583 return MSVCRT_pow(x,y);
584 }
585
586 /*********************************************************************
587 * _CIsin (MSVCRT.@)
588 */
589 double CDECL _CIsin(void)
590 {
591 FPU_DOUBLE(x);
592 return MSVCRT_sin(x);
593 }
594
595 /*********************************************************************
596 * _CIsinh (MSVCRT.@)
597 */
598 double CDECL _CIsinh(void)
599 {
600 FPU_DOUBLE(x);
601 return MSVCRT_sinh(x);
602 }
603
604 /*********************************************************************
605 * _CIsqrt (MSVCRT.@)
606 */
607 double CDECL _CIsqrt(void)
608 {
609 FPU_DOUBLE(x);
610 return MSVCRT_sqrt(x);
611 }
612
613 /*********************************************************************
614 * _CItan (MSVCRT.@)
615 */
616 double CDECL _CItan(void)
617 {
618 FPU_DOUBLE(x);
619 return MSVCRT_tan(x);
620 }
621
622 /*********************************************************************
623 * _CItanh (MSVCRT.@)
624 */
625 double CDECL _CItanh(void)
626 {
627 FPU_DOUBLE(x);
628 return MSVCRT_tanh(x);
629 }
630
631 /*********************************************************************
632 * _ftol (MSVCRT.@)
633 */
634 LONGLONG CDECL MSVCRT__ftol(void)
635 {
636 FPU_DOUBLE(x);
637 return (LONGLONG)x;
638 }
639
640 #endif /* defined(__GNUC__) && defined(__i386__) */
641
642 /*********************************************************************
643 * _fpclass (MSVCRT.@)
644 */
645 int CDECL MSVCRT__fpclass(double num)
646 {
647 #if defined(HAVE_FPCLASS) || defined(fpclass)
648 switch (fpclass( num ))
649 {
650 #ifdef FP_SNAN
651 case FP_SNAN: return MSVCRT__FPCLASS_SNAN;
652 #endif
653 #ifdef FP_QNAN
654 case FP_QNAN: return MSVCRT__FPCLASS_QNAN;
655 #endif
656 #ifdef FP_NINF
657 case FP_NINF: return MSVCRT__FPCLASS_NINF;
658 #endif
659 #ifdef FP_PINF
660 case FP_PINF: return MSVCRT__FPCLASS_PINF;
661 #endif
662 #ifdef FP_NDENORM
663 case FP_NDENORM: return MSVCRT__FPCLASS_ND;
664 #endif
665 #ifdef FP_PDENORM
666 case FP_PDENORM: return MSVCRT__FPCLASS_PD;
667 #endif
668 #ifdef FP_NZERO
669 case FP_NZERO: return MSVCRT__FPCLASS_NZ;
670 #endif
671 #ifdef FP_PZERO
672 case FP_PZERO: return MSVCRT__FPCLASS_PZ;
673 #endif
674 #ifdef FP_NNORM
675 case FP_NNORM: return MSVCRT__FPCLASS_NN;
676 #endif
677 #ifdef FP_PNORM
678 case FP_PNORM: return MSVCRT__FPCLASS_PN;
679 #endif
680 default: return MSVCRT__FPCLASS_PN;
681 }
682 #elif defined (fpclassify)
683 switch (fpclassify( num ))
684 {
685 case FP_NAN: return MSVCRT__FPCLASS_QNAN;
686 case FP_INFINITE: return signbit(num) ? MSVCRT__FPCLASS_NINF : MSVCRT__FPCLASS_PINF;
687 case FP_SUBNORMAL: return signbit(num) ?MSVCRT__FPCLASS_ND : MSVCRT__FPCLASS_PD;
688 case FP_ZERO: return signbit(num) ? MSVCRT__FPCLASS_NZ : MSVCRT__FPCLASS_PZ;
689 }
690 return signbit(num) ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN;
691 #else
692 if (!isfinite(num))
693 return MSVCRT__FPCLASS_QNAN;
694 return num == 0.0 ? MSVCRT__FPCLASS_PZ : (num < 0 ? MSVCRT__FPCLASS_NN : MSVCRT__FPCLASS_PN);
695 #endif
696 }
697
698 /*********************************************************************
699 * _rotl (MSVCRT.@)
700 */
701 unsigned int CDECL _rotl(unsigned int num, int shift)
702 {
703 shift &= 31;
704 return (num << shift) | (num >> (32-shift));
705 }
706
707 /*********************************************************************
708 * _lrotl (MSVCRT.@)
709 */
710 MSVCRT_ulong CDECL MSVCRT__lrotl(MSVCRT_ulong num, int shift)
711 {
712 shift &= 0x1f;
713 return (num << shift) | (num >> (32-shift));
714 }
715
716 /*********************************************************************
717 * _lrotr (MSVCRT.@)
718 */
719 MSVCRT_ulong CDECL MSVCRT__lrotr(MSVCRT_ulong num, int shift)
720 {
721 shift &= 0x1f;
722 return (num >> shift) | (num << (32-shift));
723 }
724
725 /*********************************************************************
726 * _rotr (MSVCRT.@)
727 */
728 unsigned int CDECL _rotr(unsigned int num, int shift)
729 {
730 shift &= 0x1f;
731 return (num >> shift) | (num << (32-shift));
732 }
733
734 /*********************************************************************
735 * _rotl64 (MSVCRT.@)
736 */
737 unsigned __int64 CDECL _rotl64(unsigned __int64 num, int shift)
738 {
739 shift &= 63;
740 return (num << shift) | (num >> (64-shift));
741 }
742
743 /*********************************************************************
744 * _rotr64 (MSVCRT.@)
745 */
746 unsigned __int64 CDECL _rotr64(unsigned __int64 num, int shift)
747 {
748 shift &= 63;
749 return (num >> shift) | (num << (64-shift));
750 }
751
752 /*********************************************************************
753 * abs (MSVCRT.@)
754 */
755 int CDECL MSVCRT_abs( int n )
756 {
757 return n >= 0 ? n : -n;
758 }
759
760 /*********************************************************************
761 * labs (MSVCRT.@)
762 */
763 MSVCRT_long CDECL MSVCRT_labs( MSVCRT_long n )
764 {
765 return n >= 0 ? n : -n;
766 }
767
768 /*********************************************************************
769 * _abs64 (MSVCRT.@)
770 */
771 __int64 CDECL _abs64( __int64 n )
772 {
773 return n >= 0 ? n : -n;
774 }
775
776 /*********************************************************************
777 * _logb (MSVCRT.@)
778 */
779 double CDECL MSVCRT__logb(double num)
780 {
781 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
782 return logb(num);
783 }
784
785 /*********************************************************************
786 * _scalb (MSVCRT.@)
787 */
788 double CDECL MSVCRT__scalb(double num, MSVCRT_long power)
789 {
790 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
791 return ldexp(num, power);
792 }
793
794 /*********************************************************************
795 * _hypot (MSVCRT.@)
796 */
797 double CDECL _hypot(double x, double y)
798 {
799 /* FIXME: errno handling */
800 return hypot( x, y );
801 }
802
803 /*********************************************************************
804 * _hypotf (MSVCRT.@)
805 */
806 float CDECL MSVCRT__hypotf(float x, float y)
807 {
808 /* FIXME: errno handling */
809 return hypotf( x, y );
810 }
811
812 /*********************************************************************
813 * ceil (MSVCRT.@)
814 */
815 double CDECL MSVCRT_ceil( double x )
816 {
817 return ceil(x);
818 }
819
820 /*********************************************************************
821 * floor (MSVCRT.@)
822 */
823 double CDECL MSVCRT_floor( double x )
824 {
825 return floor(x);
826 }
827
828 /*********************************************************************
829 * fabs (MSVCRT.@)
830 */
831 double CDECL MSVCRT_fabs( double x )
832 {
833 return fabs(x);
834 }
835
836 /*********************************************************************
837 * frexp (MSVCRT.@)
838 */
839 double CDECL MSVCRT_frexp( double x, int *exp )
840 {
841 return frexp( x, exp );
842 }
843
844 /*********************************************************************
845 * modf (MSVCRT.@)
846 */
847 double CDECL MSVCRT_modf( double x, double *iptr )
848 {
849 return modf( x, iptr );
850 }
851
852 /*********************************************************************
853 * _matherr (MSVCRT.@)
854 */
855 int CDECL MSVCRT__matherr(struct MSVCRT__exception *e)
856 {
857 if (e)
858 TRACE("(%p = %d, %s, %g %g %g)\n",e, e->type, e->name, e->arg1, e->arg2,
859 e->retval);
860 else
861 TRACE("(null)\n");
862 if (MSVCRT_default_matherr_func)
863 return MSVCRT_default_matherr_func(e);
864 ERR(":Unhandled math error!\n");
865 return 0;
866 }
867
868 /*********************************************************************
869 * __setusermatherr (MSVCRT.@)
870 */
871 void CDECL MSVCRT___setusermatherr(MSVCRT_matherr_func func)
872 {
873 MSVCRT_default_matherr_func = func;
874 TRACE(":new matherr handler %p\n", func);
875 }
876
877 /**********************************************************************
878 * _statusfp2 (MSVCRT.@)
879 *
880 * Not exported by native msvcrt, added in msvcr80.
881 */
882 #if defined(__i386__) || defined(__x86_64__)
883 void CDECL _statusfp2( unsigned int *x86_sw, unsigned int *sse2_sw )
884 {
885 #ifdef __GNUC__
886 unsigned int flags;
887 unsigned long fpword;
888
889 if (x86_sw)
890 {
891 __asm__ __volatile__( "fstsw %0" : "=m" (fpword) );
892 flags = 0;
893 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
894 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
895 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
896 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
897 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
898 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
899 *x86_sw = flags;
900 }
901
902 if (!sse2_sw) return;
903
904 if (sse2_supported)
905 {
906 __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
907 flags = 0;
908 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
909 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
910 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
911 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
912 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
913 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
914 *sse2_sw = flags;
915 }
916 else *sse2_sw = 0;
917 #else
918 FIXME( "not implemented\n" );
919 #endif
920 }
921 #endif
922
923 /**********************************************************************
924 * _statusfp (MSVCRT.@)
925 */
926 unsigned int CDECL _statusfp(void)
927 {
928 #if defined(__i386__) || defined(__x86_64__)
929 unsigned int x86_sw, sse2_sw;
930
931 _statusfp2( &x86_sw, &sse2_sw );
932 /* FIXME: there's no definition for ambiguous status, just return all status bits for now */
933 return x86_sw | sse2_sw;
934 #else
935 FIXME( "not implemented\n" );
936 return 0;
937 #endif
938 }
939
940 /*********************************************************************
941 * _clearfp (MSVCRT.@)
942 */
943 unsigned int CDECL _clearfp(void)
944 {
945 unsigned int flags = 0;
946 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
947 unsigned long fpword;
948
949 __asm__ __volatile__( "fnstsw %0; fnclex" : "=m" (fpword) );
950 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
951 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
952 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
953 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
954 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
955 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
956
957 if (sse2_supported)
958 {
959 __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
960 if (fpword & 0x1) flags |= MSVCRT__SW_INVALID;
961 if (fpword & 0x2) flags |= MSVCRT__SW_DENORMAL;
962 if (fpword & 0x4) flags |= MSVCRT__SW_ZERODIVIDE;
963 if (fpword & 0x8) flags |= MSVCRT__SW_OVERFLOW;
964 if (fpword & 0x10) flags |= MSVCRT__SW_UNDERFLOW;
965 if (fpword & 0x20) flags |= MSVCRT__SW_INEXACT;
966 fpword &= ~0x3f;
967 __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
968 }
969 #else
970 FIXME( "not implemented\n" );
971 #endif
972 return flags;
973 }
974
975 /*********************************************************************
976 * __fpecode (MSVCRT.@)
977 */
978 int * CDECL __fpecode(void)
979 {
980 return &msvcrt_get_thread_data()->fpecode;
981 }
982
983 /*********************************************************************
984 * ldexp (MSVCRT.@)
985 */
986 double CDECL MSVCRT_ldexp(double num, MSVCRT_long exp)
987 {
988 double z = ldexp(num,exp);
989
990 if (!isfinite(z))
991 *MSVCRT__errno() = MSVCRT_ERANGE;
992 else if (z == 0 && signbit(z))
993 z = 0.0; /* Convert -0 -> +0 */
994 return z;
995 }
996
997 /*********************************************************************
998 * _cabs (MSVCRT.@)
999 */
1000 double CDECL MSVCRT__cabs(struct MSVCRT__complex num)
1001 {
1002 return sqrt(num.x * num.x + num.y * num.y);
1003 }
1004
1005 /*********************************************************************
1006 * _chgsign (MSVCRT.@)
1007 */
1008 double CDECL MSVCRT__chgsign(double num)
1009 {
1010 /* FIXME: +-infinity,Nan not tested */
1011 return -num;
1012 }
1013
1014 /*********************************************************************
1015 * __control87_2 (MSVCRT.@)
1016 *
1017 * Not exported by native msvcrt, added in msvcr80.
1018 */
1019 #if defined(__i386__) || defined(__x86_64__)
1020 int CDECL __control87_2( unsigned int newval, unsigned int mask,
1021 unsigned int *x86_cw, unsigned int *sse2_cw )
1022 {
1023 #ifdef __GNUC__
1024 unsigned long fpword;
1025 unsigned int flags;
1026
1027 if (x86_cw)
1028 {
1029 __asm__ __volatile__( "fstcw %0" : "=m" (fpword) );
1030
1031 /* Convert into mask constants */
1032 flags = 0;
1033 if (fpword & 0x1) flags |= MSVCRT__EM_INVALID;
1034 if (fpword & 0x2) flags |= MSVCRT__EM_DENORMAL;
1035 if (fpword & 0x4) flags |= MSVCRT__EM_ZERODIVIDE;
1036 if (fpword & 0x8) flags |= MSVCRT__EM_OVERFLOW;
1037 if (fpword & 0x10) flags |= MSVCRT__EM_UNDERFLOW;
1038 if (fpword & 0x20) flags |= MSVCRT__EM_INEXACT;
1039 switch (fpword & 0xc00)
1040 {
1041 case 0xc00: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1042 case 0x800: flags |= MSVCRT__RC_UP; break;
1043 case 0x400: flags |= MSVCRT__RC_DOWN; break;
1044 }
1045 switch (fpword & 0x300)
1046 {
1047 case 0x0: flags |= MSVCRT__PC_24; break;
1048 case 0x200: flags |= MSVCRT__PC_53; break;
1049 case 0x300: flags |= MSVCRT__PC_64; break;
1050 }
1051 if (fpword & 0x1000) flags |= MSVCRT__IC_AFFINE;
1052
1053 TRACE( "x86 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1054 if (mask)
1055 {
1056 flags = (flags & ~mask) | (newval & mask);
1057
1058 /* Convert (masked) value back to fp word */
1059 fpword = 0;
1060 if (flags & MSVCRT__EM_INVALID) fpword |= 0x1;
1061 if (flags & MSVCRT__EM_DENORMAL) fpword |= 0x2;
1062 if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x4;
1063 if (flags & MSVCRT__EM_OVERFLOW) fpword |= 0x8;
1064 if (flags & MSVCRT__EM_UNDERFLOW) fpword |= 0x10;
1065 if (flags & MSVCRT__EM_INEXACT) fpword |= 0x20;
1066 switch (flags & MSVCRT__MCW_RC)
1067 {
1068 case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0xc00; break;
1069 case MSVCRT__RC_UP: fpword |= 0x800; break;
1070 case MSVCRT__RC_DOWN: fpword |= 0x400; break;
1071 }
1072 switch (flags & MSVCRT__MCW_PC)
1073 {
1074 case MSVCRT__PC_64: fpword |= 0x300; break;
1075 case MSVCRT__PC_53: fpword |= 0x200; break;
1076 case MSVCRT__PC_24: fpword |= 0x0; break;
1077 }
1078 if (flags & MSVCRT__IC_AFFINE) fpword |= 0x1000;
1079
1080 __asm__ __volatile__( "fldcw %0" : : "m" (fpword) );
1081 }
1082 *x86_cw = flags;
1083 }
1084
1085 if (!sse2_cw) return 1;
1086
1087 if (sse2_supported)
1088 {
1089 __asm__ __volatile__( "stmxcsr %0" : "=m" (fpword) );
1090
1091 /* Convert into mask constants */
1092 flags = 0;
1093 if (fpword & 0x80) flags |= MSVCRT__EM_INVALID;
1094 if (fpword & 0x100) flags |= MSVCRT__EM_DENORMAL;
1095 if (fpword & 0x200) flags |= MSVCRT__EM_ZERODIVIDE;
1096 if (fpword & 0x400) flags |= MSVCRT__EM_OVERFLOW;
1097 if (fpword & 0x800) flags |= MSVCRT__EM_UNDERFLOW;
1098 if (fpword & 0x1000) flags |= MSVCRT__EM_INEXACT;
1099 switch (fpword & 0x6000)
1100 {
1101 case 0x6000: flags |= MSVCRT__RC_UP|MSVCRT__RC_DOWN; break;
1102 case 0x4000: flags |= MSVCRT__RC_UP; break;
1103 case 0x2000: flags |= MSVCRT__RC_DOWN; break;
1104 }
1105 switch (fpword & 0x8040)
1106 {
1107 case 0x0040: flags |= MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS; break;
1108 case 0x8000: flags |= MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS; break;
1109 case 0x8040: flags |= MSVCRT__DN_FLUSH; break;
1110 }
1111
1112 TRACE( "sse2 flags=%08x newval=%08x mask=%08x\n", flags, newval, mask );
1113 if (mask)
1114 {
1115 flags = (flags & ~mask) | (newval & mask);
1116
1117 /* Convert (masked) value back to fp word */
1118 fpword = 0;
1119 if (flags & MSVCRT__EM_INVALID) fpword |= 0x80;
1120 if (flags & MSVCRT__EM_DENORMAL) fpword |= 0x100;
1121 if (flags & MSVCRT__EM_ZERODIVIDE) fpword |= 0x200;
1122 if (flags & MSVCRT__EM_OVERFLOW) fpword |= 0x400;
1123 if (flags & MSVCRT__EM_UNDERFLOW) fpword |= 0x800;
1124 if (flags & MSVCRT__EM_INEXACT) fpword |= 0x1000;
1125 switch (flags & MSVCRT__MCW_RC)
1126 {
1127 case MSVCRT__RC_UP|MSVCRT__RC_DOWN: fpword |= 0x6000; break;
1128 case MSVCRT__RC_UP: fpword |= 0x4000; break;
1129 case MSVCRT__RC_DOWN: fpword |= 0x2000; break;
1130 }
1131 switch (flags & MSVCRT__MCW_DN)
1132 {
1133 case MSVCRT__DN_FLUSH_OPERANDS_SAVE_RESULTS: fpword |= 0x0040; break;
1134 case MSVCRT__DN_SAVE_OPERANDS_FLUSH_RESULTS: fpword |= 0x8000; break;
1135 case MSVCRT__DN_FLUSH: fpword |= 0x8040; break;
1136 }
1137 __asm__ __volatile__( "ldmxcsr %0" : : "m" (fpword) );
1138 }
1139 *sse2_cw = flags;
1140 }
1141 else *sse2_cw = 0;
1142
1143 return 1;
1144 #else
1145 FIXME( "not implemented\n" );
1146 return 0;
1147 #endif
1148 }
1149 #endif
1150
1151 /*********************************************************************
1152 * _control87 (MSVCRT.@)
1153 */
1154 unsigned int CDECL _control87(unsigned int newval, unsigned int mask)
1155 {
1156 #if defined(__i386__) || defined(__x86_64__)
1157 unsigned int x86_cw, sse2_cw;
1158
1159 __control87_2( newval, mask, &x86_cw, &sse2_cw );
1160
1161 if ((x86_cw ^ sse2_cw) & (MSVCRT__MCW_EM | MSVCRT__MCW_RC)) x86_cw |= MSVCRT__EM_AMBIGUOUS;
1162 return x86_cw;
1163 #else
1164 FIXME( "not implemented\n" );
1165 return 0;
1166 #endif
1167 }
1168
1169 /*********************************************************************
1170 * _controlfp (MSVCRT.@)
1171 */
1172 unsigned int CDECL _controlfp(unsigned int newval, unsigned int mask)
1173 {
1174 return _control87( newval, mask & ~MSVCRT__EM_DENORMAL );
1175 }
1176
1177 /*********************************************************************
1178 * _set_controlfp (MSVCRT.@)
1179 */
1180 void CDECL _set_controlfp( unsigned int newval, unsigned int mask )
1181 {
1182 _controlfp( newval, mask );
1183 }
1184
1185 /*********************************************************************
1186 * _controlfp_s (MSVCRT.@)
1187 */
1188 int CDECL _controlfp_s(unsigned int *cur, unsigned int newval, unsigned int mask)
1189 {
1190 static const unsigned int all_flags = (MSVCRT__MCW_EM | MSVCRT__MCW_IC | MSVCRT__MCW_RC |
1191 MSVCRT__MCW_PC | MSVCRT__MCW_DN);
1192 unsigned int val;
1193
1194 if (!MSVCRT_CHECK_PMT( !(newval & mask & ~all_flags) ))
1195 {
1196 if (cur) *cur = _controlfp( 0, 0 ); /* retrieve it anyway */
1197 return MSVCRT_EINVAL;
1198 }
1199 val = _controlfp( newval, mask );
1200 if (cur) *cur = val;
1201 return 0;
1202 }
1203
1204 /*********************************************************************
1205 * _copysign (MSVCRT.@)
1206 */
1207 double CDECL MSVCRT__copysign(double num, double sign)
1208 {
1209 /* FIXME: Behaviour for Nan/Inf? */
1210 if (sign < 0.0)
1211 return num < 0.0 ? num : -num;
1212 return num < 0.0 ? -num : num;
1213 }
1214
1215 /*********************************************************************
1216 * _finite (MSVCRT.@)
1217 */
1218 int CDECL MSVCRT__finite(double num)
1219 {
1220 return isfinite(num) != 0; /* See comment for _isnan() */
1221 }
1222
1223 /*********************************************************************
1224 * _fpreset (MSVCRT.@)
1225 */
1226 void CDECL _fpreset(void)
1227 {
1228 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
1229 const unsigned int x86_cw = 0x27f;
1230 __asm__ __volatile__( "fninit; fldcw %0" : : "m" (x86_cw) );
1231 if (sse2_supported)
1232 {
1233 const unsigned long sse2_cw = 0x1f80;
1234 __asm__ __volatile__( "ldmxcsr %0" : : "m" (sse2_cw) );
1235 }
1236 #else
1237 FIXME( "not implemented\n" );
1238 #endif
1239 }
1240
1241 /*********************************************************************
1242 * _isnan (MSVCRT.@)
1243 */
1244 INT CDECL MSVCRT__isnan(double num)
1245 {
1246 /* Some implementations return -1 for true(glibc), msvcrt/crtdll return 1.
1247 * Do the same, as the result may be used in calculations
1248 */
1249 return isnan(num) != 0;
1250 }
1251
1252 /*********************************************************************
1253 * _j0 (MSVCRT.@)
1254 */
1255 double CDECL MSVCRT__j0(double num)
1256 {
1257 /* FIXME: errno handling */
1258 return j0(num);
1259 }
1260
1261 /*********************************************************************
1262 * _j1 (MSVCRT.@)
1263 */
1264 double CDECL MSVCRT__j1(double num)
1265 {
1266 /* FIXME: errno handling */
1267 return j1(num);
1268 }
1269
1270 /*********************************************************************
1271 * _jn (MSVCRT.@)
1272 */
1273 double CDECL MSVCRT__jn(int n, double num)
1274 {
1275 /* FIXME: errno handling */
1276 return jn(n, num);
1277 }
1278
1279 /*********************************************************************
1280 * _y0 (MSVCRT.@)
1281 */
1282 double CDECL MSVCRT__y0(double num)
1283 {
1284 double retval;
1285 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1286 retval = y0(num);
1287 if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1288 {
1289 *MSVCRT__errno() = MSVCRT_EDOM;
1290 retval = sqrt(-1);
1291 }
1292 return retval;
1293 }
1294
1295 /*********************************************************************
1296 * _y1 (MSVCRT.@)
1297 */
1298 double CDECL MSVCRT__y1(double num)
1299 {
1300 double retval;
1301 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1302 retval = y1(num);
1303 if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1304 {
1305 *MSVCRT__errno() = MSVCRT_EDOM;
1306 retval = sqrt(-1);
1307 }
1308 return retval;
1309 }
1310
1311 /*********************************************************************
1312 * _yn (MSVCRT.@)
1313 */
1314 double CDECL MSVCRT__yn(int order, double num)
1315 {
1316 double retval;
1317 if (!isfinite(num)) *MSVCRT__errno() = MSVCRT_EDOM;
1318 retval = yn(order,num);
1319 if (MSVCRT__fpclass(retval) == MSVCRT__FPCLASS_NINF)
1320 {
1321 *MSVCRT__errno() = MSVCRT_EDOM;
1322 retval = sqrt(-1);
1323 }
1324 return retval;
1325 }
1326
1327 /*********************************************************************
1328 * _nextafter (MSVCRT.@)
1329 */
1330 double CDECL MSVCRT__nextafter(double num, double next)
1331 {
1332 double retval;
1333 if (!isfinite(num) || !isfinite(next)) *MSVCRT__errno() = MSVCRT_EDOM;
1334 retval = nextafter(num,next);
1335 return retval;
1336 }
1337
1338 /*********************************************************************
1339 * _ecvt (MSVCRT.@)
1340 */
1341 char * CDECL _ecvt( double number, int ndigits, int *decpt, int *sign )
1342 {
1343 int prec, len;
1344 thread_data_t *data = msvcrt_get_thread_data();
1345 /* FIXME: check better for overflow (native supports over 300 chars) */
1346 ndigits = min( ndigits, 80 - 7); /* 7 : space for dec point, 1 for "e",
1347 * 4 for exponent and one for
1348 * terminating '\0' */
1349 if (!data->efcvt_buffer)
1350 data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1351
1352 if( number < 0) {
1353 *sign = TRUE;
1354 number = -number;
1355 } else
1356 *sign = FALSE;
1357 /* handle cases with zero ndigits or less */
1358 prec = ndigits;
1359 if( prec < 1) prec = 2;
1360 len = snprintf(data->efcvt_buffer, 80, "%.*le", prec - 1, number);
1361 /* take the decimal "point away */
1362 if( prec != 1)
1363 memmove( data->efcvt_buffer + 1, data->efcvt_buffer + 2, len - 1 );
1364 /* take the exponential "e" out */
1365 data->efcvt_buffer[ prec] = '\0';
1366 /* read the exponent */
1367 sscanf( data->efcvt_buffer + prec + 1, "%d", decpt);
1368 (*decpt)++;
1369 /* adjust for some border cases */
1370 if( data->efcvt_buffer[0] == '0')/* value is zero */
1371 *decpt = 0;
1372 /* handle cases with zero ndigits or less */
1373 if( ndigits < 1){
1374 if( data->efcvt_buffer[ 0] >= '5')
1375 (*decpt)++;
1376 data->efcvt_buffer[ 0] = '\0';
1377 }
1378 TRACE("out=\"%s\"\n",data->efcvt_buffer);
1379 return data->efcvt_buffer;
1380 }
1381
1382 /*********************************************************************
1383 * _ecvt_s (MSVCRT.@)
1384 */
1385 int CDECL _ecvt_s( char *buffer, MSVCRT_size_t length, double number, int ndigits, int *decpt, int *sign )
1386 {
1387 int prec, len;
1388 char *result;
1389 const char infret[] = "1#INF";
1390
1391 if (!MSVCRT_CHECK_PMT(buffer != NULL)) return MSVCRT_EINVAL;
1392 if (!MSVCRT_CHECK_PMT(decpt != NULL)) return MSVCRT_EINVAL;
1393 if (!MSVCRT_CHECK_PMT(sign != NULL)) return MSVCRT_EINVAL;
1394 if (!MSVCRT_CHECK_PMT_ERR( length > 2, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1395 if (!MSVCRT_CHECK_PMT_ERR(ndigits < (int)length - 1, MSVCRT_ERANGE )) return MSVCRT_ERANGE;
1396
1397 /* special case - inf */
1398 if(number == HUGE_VAL || number == -HUGE_VAL)
1399 {
1400 memset(buffer, '0', ndigits);
1401 memcpy(buffer, infret, min(ndigits, sizeof(infret) - 1 ) );
1402 buffer[ndigits] = '\0';
1403 (*decpt) = 1;
1404 if(number == -HUGE_VAL)
1405 (*sign) = 1;
1406 else
1407 (*sign) = 0;
1408 return 0;
1409 }
1410 /* handle cases with zero ndigits or less */
1411 prec = ndigits;
1412 if( prec < 1) prec = 2;
1413 result = MSVCRT_malloc(prec + 7);
1414
1415 if( number < 0) {
1416 *sign = TRUE;
1417 number = -number;
1418 } else
1419 *sign = FALSE;
1420 len = snprintf(result, prec + 7, "%.*le", prec - 1, number);
1421 /* take the decimal "point away */
1422 if( prec != 1)
1423 memmove( result + 1, result + 2, len - 1 );
1424 /* take the exponential "e" out */
1425 result[ prec] = '\0';
1426 /* read the exponent */
1427 sscanf( result + prec + 1, "%d", decpt);
1428 (*decpt)++;
1429 /* adjust for some border cases */
1430 if( result[0] == '0')/* value is zero */
1431 *decpt = 0;
1432 /* handle cases with zero ndigits or less */
1433 if( ndigits < 1){
1434 if( result[ 0] >= '5')
1435 (*decpt)++;
1436 result[ 0] = '\0';
1437 }
1438 memcpy( buffer, result, max(ndigits + 1, 1) );
1439 MSVCRT_free( result );
1440 return 0;
1441 }
1442
1443 /***********************************************************************
1444 * _fcvt (MSVCRT.@)
1445 */
1446 char * CDECL _fcvt( double number, int ndigits, int *decpt, int *sign )
1447 {
1448 thread_data_t *data = msvcrt_get_thread_data();
1449 int stop, dec1, dec2;
1450 char *ptr1, *ptr2, *first;
1451 char buf[80]; /* ought to be enough */
1452
1453 if (!data->efcvt_buffer)
1454 data->efcvt_buffer = MSVCRT_malloc( 80 ); /* ought to be enough */
1455
1456 if (number < 0)
1457 {
1458 *sign = 1;
1459 number = -number;
1460 } else *sign = 0;
1461
1462 snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1463 ptr1 = buf;
1464 ptr2 = data->efcvt_buffer;
1465 first = NULL;
1466 dec1 = 0;
1467 dec2 = 0;
1468
1469 /* For numbers below the requested resolution, work out where
1470 the decimal point will be rather than finding it in the string */
1471 if (number < 1.0 && number > 0.0) {
1472 dec2 = log10(number + 1e-10);
1473 if (-dec2 <= ndigits) dec2 = 0;
1474 }
1475
1476 /* If requested digits is zero or less, we will need to truncate
1477 * the returned string */
1478 if (ndigits < 1) {
1479 stop = strlen(buf) + ndigits;
1480 } else {
1481 stop = strlen(buf);
1482 }
1483
1484 while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1485 while (*ptr1 != '\0' && *ptr1 != '.') {
1486 if (!first) first = ptr2;
1487 if ((ptr1 - buf) < stop) {
1488 *ptr2++ = *ptr1++;
1489 } else {
1490 ptr1++;
1491 }
1492 dec1++;
1493 }
1494
1495 if (ndigits > 0) {
1496 ptr1++;
1497 if (!first) {
1498 while (*ptr1 == '0') { /* Process leading zeroes */
1499 *ptr2++ = *ptr1++;
1500 dec1--;
1501 }
1502 }
1503 while (*ptr1 != '\0') {
1504 if (!first) first = ptr2;
1505 *ptr2++ = *ptr1++;
1506 }
1507 }
1508
1509 *ptr2 = '\0';
1510
1511 /* We never found a non-zero digit, then our number is either
1512 * smaller than the requested precision, or 0.0 */
1513 if (!first) {
1514 if (number > 0.0) {
1515 first = ptr2;
1516 } else {
1517 first = data->efcvt_buffer;
1518 dec1 = 0;
1519 }
1520 }
1521
1522 *decpt = dec2 ? dec2 : dec1;
1523 return first;
1524 }
1525
1526 /***********************************************************************
1527 * _fcvt_s (MSVCRT.@)
1528 */
1529 int CDECL _fcvt_s(char* outbuffer, MSVCRT_size_t size, double number, int ndigits, int *decpt, int *sign)
1530 {
1531 int stop, dec1, dec2;
1532 char *ptr1, *ptr2, *first;
1533 char buf[80]; /* ought to be enough */
1534
1535 if (!outbuffer || !decpt || !sign || size == 0)
1536 {
1537 *MSVCRT__errno() = MSVCRT_EINVAL;
1538 return MSVCRT_EINVAL;
1539 }
1540
1541 if (number < 0)
1542 {
1543 *sign = 1;
1544 number = -number;
1545 } else *sign = 0;
1546
1547 snprintf(buf, 80, "%.*f", ndigits < 0 ? 0 : ndigits, number);
1548 ptr1 = buf;
1549 ptr2 = outbuffer;
1550 first = NULL;
1551 dec1 = 0;
1552 dec2 = 0;
1553
1554 /* For numbers below the requested resolution, work out where
1555 the decimal point will be rather than finding it in the string */
1556 if (number < 1.0 && number > 0.0) {
1557 dec2 = log10(number + 1e-10);
1558 if (-dec2 <= ndigits) dec2 = 0;
1559 }
1560
1561 /* If requested digits is zero or less, we will need to truncate
1562 * the returned string */
1563 if (ndigits < 1) {
1564 stop = strlen(buf) + ndigits;
1565 } else {
1566 stop = strlen(buf);
1567 }
1568
1569 while (*ptr1 == '0') ptr1++; /* Skip leading zeroes */
1570 while (*ptr1 != '\0' && *ptr1 != '.') {
1571 if (!first) first = ptr2;
1572 if ((ptr1 - buf) < stop) {
1573 if (size > 1) {
1574 *ptr2++ = *ptr1++;
1575 size--;
1576 }
1577 } else {
1578 ptr1++;
1579 }
1580 dec1++;
1581 }
1582
1583 if (ndigits > 0) {
1584 ptr1++;
1585 if (!first) {
1586 while (*ptr1 == '0') { /* Process leading zeroes */
1587 if (number == 0.0 && size > 1) {
1588 *ptr2++ = '0';
1589 size--;
1590 }
1591 ptr1++;
1592 dec1--;
1593 }
1594 }
1595 while (*ptr1 != '\0') {
1596 if (!first) first = ptr2;
1597 if (size > 1) {
1598 *ptr2++ = *ptr1++;
1599 size--;
1600 }
1601 }
1602 }
1603
1604 *ptr2 = '\0';
1605
1606 /* We never found a non-zero digit, then our number is either
1607 * smaller than the requested precision, or 0.0 */
1608 if (!first && (number <= 0.0))
1609 dec1 = 0;
1610
1611 *decpt = dec2 ? dec2 : dec1;
1612 return 0;
1613 }
1614
1615 /***********************************************************************
1616 * _gcvt (MSVCRT.@)
1617 */
1618 char * CDECL _gcvt( double number, int ndigit, char *buff )
1619 {
1620 if(!buff) {
1621 *MSVCRT__errno() = MSVCRT_EINVAL;
1622 return NULL;
1623 }
1624
1625 if(ndigit < 0) {
1626 *MSVCRT__errno() = MSVCRT_ERANGE;
1627 return NULL;
1628 }
1629
1630 MSVCRT_sprintf(buff, "%.*g", ndigit, number);
1631 return buff;
1632 }
1633
1634 /***********************************************************************
1635 * _gcvt_s (MSVCRT.@)
1636 */
1637 int CDECL _gcvt_s(char *buff, MSVCRT_size_t size, double number, int digits)
1638 {
1639 int len;
1640
1641 if(!buff) {
1642 *MSVCRT__errno() = MSVCRT_EINVAL;
1643 return MSVCRT_EINVAL;
1644 }
1645
1646 if( digits<0 || digits>=size) {
1647 if(size)
1648 buff[0] = '\0';
1649
1650 *MSVCRT__errno() = MSVCRT_ERANGE;
1651 return MSVCRT_ERANGE;
1652 }
1653
1654 len = MSVCRT__scprintf("%.*g", digits, number);
1655 if(len > size) {
1656 buff[0] = '\0';
1657 *MSVCRT__errno() = MSVCRT_ERANGE;
1658 return MSVCRT_ERANGE;
1659 }
1660
1661 MSVCRT_sprintf(buff, "%.*g", digits, number);
1662 return 0;
1663 }
1664
1665 #include <stdlib.h> /* div_t, ldiv_t */
1666
1667 /*********************************************************************
1668 * div (MSVCRT.@)
1669 * VERSION
1670 * [i386] Windows binary compatible - returns the struct in eax/edx.
1671 */
1672 #ifdef __i386__
1673 unsigned __int64 CDECL MSVCRT_div(int num, int denom)
1674 {
1675 div_t dt = div(num,denom);
1676 return ((unsigned __int64)dt.rem << 32) | (unsigned int)dt.quot;
1677 }
1678 #else
1679 /*********************************************************************
1680 * div (MSVCRT.@)
1681 * VERSION
1682 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1683 */
1684 MSVCRT_div_t CDECL MSVCRT_div(int num, int denom)
1685 {
1686 div_t dt = div(num,denom);
1687 MSVCRT_div_t ret;
1688 ret.quot = dt.quot;
1689 ret.rem = dt.rem;
1690
1691 return ret;
1692
1693 }
1694 #endif /* ifdef __i386__ */
1695
1696
1697 /*********************************************************************
1698 * ldiv (MSVCRT.@)
1699 * VERSION
1700 * [i386] Windows binary compatible - returns the struct in eax/edx.
1701 */
1702 #ifdef __i386__
1703 unsigned __int64 CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1704 {
1705 ldiv_t ldt = ldiv(num,denom);
1706 return ((unsigned __int64)ldt.rem << 32) | (MSVCRT_ulong)ldt.quot;
1707 }
1708 #else
1709 /*********************************************************************
1710 * ldiv (MSVCRT.@)
1711 * VERSION
1712 * [!i386] Non-x86 can't run win32 apps so we don't need binary compatibility
1713 */
1714 MSVCRT_ldiv_t CDECL MSVCRT_ldiv(MSVCRT_long num, MSVCRT_long denom)
1715 {
1716 ldiv_t result = ldiv(num,denom);
1717
1718 MSVCRT_ldiv_t ret;
1719 ret.quot = result.quot;
1720 ret.rem = result.rem;
1721
1722 return ret;
1723 }
1724 #endif /* ifdef __i386__ */
1725
1726 #ifdef __i386__
1727
1728 /*********************************************************************
1729 * _adjust_fdiv (MSVCRT.@)
1730 * Used by the MSVC compiler to work around the Pentium FDIV bug.
1731 */
1732 int MSVCRT__adjust_fdiv = 0;
1733
1734 /***********************************************************************
1735 * _adj_fdiv_m16i (MSVCRT.@)
1736 *
1737 * NOTE
1738 * I _think_ this function is intended to work around the Pentium
1739 * fdiv bug.
1740 */
1741 void __stdcall _adj_fdiv_m16i( short arg )
1742 {
1743 TRACE("(): stub\n");
1744 }
1745
1746 /***********************************************************************
1747 * _adj_fdiv_m32 (MSVCRT.@)
1748 *
1749 * NOTE
1750 * I _think_ this function is intended to work around the Pentium
1751 * fdiv bug.
1752 */
1753 void __stdcall _adj_fdiv_m32( unsigned int arg )
1754 {
1755 TRACE("(): stub\n");
1756 }
1757
1758 /***********************************************************************
1759 * _adj_fdiv_m32i (MSVCRT.@)
1760 *
1761 * NOTE
1762 * I _think_ this function is intended to work around the Pentium
1763 * fdiv bug.
1764 */
1765 void __stdcall _adj_fdiv_m32i( int arg )
1766 {
1767 TRACE("(): stub\n");
1768 }
1769
1770 /***********************************************************************
1771 * _adj_fdiv_m64 (MSVCRT.@)
1772 *
1773 * NOTE
1774 * I _think_ this function is intended to work around the Pentium
1775 * fdiv bug.
1776 */
1777 void __stdcall _adj_fdiv_m64( unsigned __int64 arg )
1778 {
1779 TRACE("(): stub\n");
1780 }
1781
1782 /***********************************************************************
1783 * _adj_fdiv_r (MSVCRT.@)
1784 * FIXME
1785 * This function is likely to have the wrong number of arguments.
1786 *
1787 * NOTE
1788 * I _think_ this function is intended to work around the Pentium
1789 * fdiv bug.
1790 */
1791 void _adj_fdiv_r(void)
1792 {
1793 TRACE("(): stub\n");
1794 }
1795
1796 /***********************************************************************
1797 * _adj_fdivr_m16i (MSVCRT.@)
1798 *
1799 * NOTE
1800 * I _think_ this function is intended to work around the Pentium
1801 * fdiv bug.
1802 */
1803 void __stdcall _adj_fdivr_m16i( short arg )
1804 {
1805 TRACE("(): stub\n");
1806 }
1807
1808 /***********************************************************************
1809 * _adj_fdivr_m32 (MSVCRT.@)
1810 *
1811 * NOTE
1812 * I _think_ this function is intended to work around the Pentium
1813 * fdiv bug.
1814 */
1815 void __stdcall _adj_fdivr_m32( unsigned int arg )
1816 {
1817 TRACE("(): stub\n");
1818 }
1819
1820 /***********************************************************************
1821 * _adj_fdivr_m32i (MSVCRT.@)
1822 *
1823 * NOTE
1824 * I _think_ this function is intended to work around the Pentium
1825 * fdiv bug.
1826 */
1827 void __stdcall _adj_fdivr_m32i( int arg )
1828 {
1829 TRACE("(): stub\n");
1830 }
1831
1832 /***********************************************************************
1833 * _adj_fdivr_m64 (MSVCRT.@)
1834 *
1835 * NOTE
1836 * I _think_ this function is intended to work around the Pentium
1837 * fdiv bug.
1838 */
1839 void __stdcall _adj_fdivr_m64( unsigned __int64 arg )
1840 {
1841 TRACE("(): stub\n");
1842 }
1843
1844 /***********************************************************************
1845 * _adj_fpatan (MSVCRT.@)
1846 * FIXME
1847 * This function is likely to have the wrong number of arguments.
1848 *
1849 * NOTE
1850 * I _think_ this function is intended to work around the Pentium
1851 * fdiv bug.
1852 */
1853 void _adj_fpatan(void)
1854 {
1855 TRACE("(): stub\n");
1856 }
1857
1858 /***********************************************************************
1859 * _adj_fprem (MSVCRT.@)
1860 * FIXME
1861 * This function is likely to have the wrong number of arguments.
1862 *
1863 * NOTE
1864 * I _think_ this function is intended to work around the Pentium
1865 * fdiv bug.
1866 */
1867 void _adj_fprem(void)
1868 {
1869 TRACE("(): stub\n");
1870 }
1871
1872 /***********************************************************************
1873 * _adj_fprem1 (MSVCRT.@)
1874 * FIXME
1875 * This function is likely to have the wrong number of arguments.
1876 *
1877 * NOTE
1878 * I _think_ this function is intended to work around the Pentium
1879 * fdiv bug.
1880 */
1881 void _adj_fprem1(void)
1882 {
1883 TRACE("(): stub\n");
1884 }
1885
1886 /***********************************************************************
1887 * _adj_fptan (MSVCRT.@)
1888 * FIXME
1889 * This function is likely to have the wrong number of arguments.
1890 *
1891 * NOTE
1892 * I _think_ this function is intended to work around the Pentium
1893 * fdiv bug.
1894 */
1895 void _adj_fptan(void)
1896 {
1897 TRACE("(): stub\n");
1898 }
1899
1900 /***********************************************************************
1901 * _safe_fdiv (MSVCRT.@)
1902 * FIXME
1903 * This function is likely to have the wrong number of arguments.
1904 *
1905 * NOTE
1906 * I _think_ this function is intended to work around the Pentium
1907 * fdiv bug.
1908 */
1909 void _safe_fdiv(void)
1910 {
1911 TRACE("(): stub\n");
1912 }
1913
1914 /***********************************************************************
1915 * _safe_fdivr (MSVCRT.@)
1916 * FIXME
1917 * This function is likely to have the wrong number of arguments.
1918 *
1919 * NOTE
1920 * I _think_ this function is intended to work around the Pentium
1921 * fdiv bug.
1922 */
1923 void _safe_fdivr(void)
1924 {
1925 TRACE("(): stub\n");
1926 }
1927
1928 /***********************************************************************
1929 * _safe_fprem (MSVCRT.@)
1930 * FIXME
1931 * This function is likely to have the wrong number of arguments.
1932 *
1933 * NOTE
1934 * I _think_ this function is intended to work around the Pentium
1935 * fdiv bug.
1936 */
1937 void _safe_fprem(void)
1938 {
1939 TRACE("(): stub\n");
1940 }
1941
1942 /***********************************************************************
1943 * _safe_fprem1 (MSVCRT.@)
1944 *
1945 * FIXME
1946 * This function is likely to have the wrong number of arguments.
1947 *
1948 * NOTE
1949 * I _think_ this function is intended to work around the Pentium
1950 * fdiv bug.
1951 */
1952 void _safe_fprem1(void)
1953 {
1954 TRACE("(): stub\n");
1955 }
1956
1957 /***********************************************************************
1958 * __libm_sse2_acos (MSVCRT.@)
1959 */
1960 void __cdecl __libm_sse2_acos(void)
1961 {
1962 double d;
1963 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
1964 d = acos( d );
1965 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
1966 }
1967
1968 /***********************************************************************
1969 * __libm_sse2_acosf (MSVCRT.@)
1970 */
1971 void __cdecl __libm_sse2_acosf(void)
1972 {
1973 float f;
1974 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
1975 f = acosf( f );
1976 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
1977 }
1978
1979 /***********************************************************************
1980 * __libm_sse2_asin (MSVCRT.@)
1981 */
1982 void __cdecl __libm_sse2_asin(void)
1983 {
1984 double d;
1985 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
1986 d = asin( d );
1987 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
1988 }
1989
1990 /***********************************************************************
1991 * __libm_sse2_asinf (MSVCRT.@)
1992 */
1993 void __cdecl __libm_sse2_asinf(void)
1994 {
1995 float f;
1996 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
1997 f = asinf( f );
1998 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
1999 }
2000
2001 /***********************************************************************
2002 * __libm_sse2_atan (MSVCRT.@)
2003 */
2004 void __cdecl __libm_sse2_atan(void)
2005 {
2006 double d;
2007 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2008 d = atan( d );
2009 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2010 }
2011
2012 /***********************************************************************
2013 * __libm_sse2_atan2 (MSVCRT.@)
2014 */
2015 void __cdecl __libm_sse2_atan2(void)
2016 {
2017 double d1, d2;
2018 __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2019 d1 = atan2( d1, d2 );
2020 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2021 }
2022
2023 /***********************************************************************
2024 * __libm_sse2_atanf (MSVCRT.@)
2025 */
2026 void __cdecl __libm_sse2_atanf(void)
2027 {
2028 float f;
2029 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2030 f = atanf( f );
2031 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2032 }
2033
2034 /***********************************************************************
2035 * __libm_sse2_cos (MSVCRT.@)
2036 */
2037 void __cdecl __libm_sse2_cos(void)
2038 {
2039 double d;
2040 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2041 d = cos( d );
2042 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2043 }
2044
2045 /***********************************************************************
2046 * __libm_sse2_cosf (MSVCRT.@)
2047 */
2048 void __cdecl __libm_sse2_cosf(void)
2049 {
2050 float f;
2051 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2052 f = cosf( f );
2053 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2054 }
2055
2056 /***********************************************************************
2057 * __libm_sse2_exp (MSVCRT.@)
2058 */
2059 void __cdecl __libm_sse2_exp(void)
2060 {
2061 double d;
2062 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2063 d = exp( d );
2064 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2065 }
2066
2067 /***********************************************************************
2068 * __libm_sse2_expf (MSVCRT.@)
2069 */
2070 void __cdecl __libm_sse2_expf(void)
2071 {
2072 float f;
2073 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2074 f = expf( f );
2075 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2076 }
2077
2078 /***********************************************************************
2079 * __libm_sse2_log (MSVCRT.@)
2080 */
2081 void __cdecl __libm_sse2_log(void)
2082 {
2083 double d;
2084 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2085 d = log( d );
2086 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2087 }
2088
2089 /***********************************************************************
2090 * __libm_sse2_log10 (MSVCRT.@)
2091 */
2092 void __cdecl __libm_sse2_log10(void)
2093 {
2094 double d;
2095 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2096 d = log10( d );
2097 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2098 }
2099
2100 /***********************************************************************
2101 * __libm_sse2_log10f (MSVCRT.@)
2102 */
2103 void __cdecl __libm_sse2_log10f(void)
2104 {
2105 float f;
2106 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2107 f = log10f( f );
2108 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2109 }
2110
2111 /***********************************************************************
2112 * __libm_sse2_logf (MSVCRT.@)
2113 */
2114 void __cdecl __libm_sse2_logf(void)
2115 {
2116 float f;
2117 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2118 f = logf( f );
2119 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2120 }
2121
2122 /***********************************************************************
2123 * __libm_sse2_pow (MSVCRT.@)
2124 */
2125 void __cdecl __libm_sse2_pow(void)
2126 {
2127 double d1, d2;
2128 __asm__ __volatile__( "movq %%xmm0,%0; movq %%xmm1,%1 " : "=m" (d1), "=m" (d2) );
2129 d1 = pow( d1, d2 );
2130 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d1) );
2131 }
2132
2133 /***********************************************************************
2134 * __libm_sse2_powf (MSVCRT.@)
2135 */
2136 void __cdecl __libm_sse2_powf(void)
2137 {
2138 float f1, f2;
2139 __asm__ __volatile__( "movd %%xmm0,%0; movd %%xmm1,%1" : "=g" (f1), "=g" (f2) );
2140 f1 = powf( f1, f2 );
2141 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f1) );
2142 }
2143
2144 /***********************************************************************
2145 * __libm_sse2_sin (MSVCRT.@)
2146 */
2147 void __cdecl __libm_sse2_sin(void)
2148 {
2149 double d;
2150 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2151 d = sin( d );
2152 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2153 }
2154
2155 /***********************************************************************
2156 * __libm_sse2_sinf (MSVCRT.@)
2157 */
2158 void __cdecl __libm_sse2_sinf(void)
2159 {
2160 float f;
2161 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2162 f = sinf( f );
2163 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2164 }
2165
2166 /***********************************************************************
2167 * __libm_sse2_tan (MSVCRT.@)
2168 */
2169 void __cdecl __libm_sse2_tan(void)
2170 {
2171 double d;
2172 __asm__ __volatile__( "movq %%xmm0,%0" : "=m" (d) );
2173 d = tan( d );
2174 __asm__ __volatile__( "movq %0,%%xmm0" : : "m" (d) );
2175 }
2176
2177 /***********************************************************************
2178 * __libm_sse2_tanf (MSVCRT.@)
2179 */
2180 void __cdecl __libm_sse2_tanf(void)
2181 {
2182 float f;
2183 __asm__ __volatile__( "movd %%xmm0,%0" : "=g" (f) );
2184 f = tanf( f );
2185 __asm__ __volatile__( "movd %0,%%xmm0" : : "g" (f) );
2186 }
2187
2188 #endif /* __i386__ */
Windows API implementation