1 | /* Test compilation of tgmath macros. |
2 | Copyright (C) 2001-2022 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <https://www.gnu.org/licenses/>. */ |
18 | |
19 | #ifndef HAVE_MAIN |
20 | #include <float.h> |
21 | #include <math.h> |
22 | #include <stdint.h> |
23 | #include <stdio.h> |
24 | #include <tgmath.h> |
25 | |
26 | //#define DEBUG |
27 | |
28 | static void compile_test (void); |
29 | static void compile_testf (void); |
30 | #if LDBL_MANT_DIG > DBL_MANT_DIG |
31 | static void compile_testl (void); |
32 | #endif |
33 | |
34 | float fx; |
35 | double dx; |
36 | long double lx; |
37 | const float fy = 1.25; |
38 | const double dy = 1.25; |
39 | const long double ly = 1.25; |
40 | complex float fz; |
41 | complex double dz; |
42 | complex long double lz; |
43 | |
44 | volatile int count_double; |
45 | volatile int count_float; |
46 | volatile int count_ldouble; |
47 | volatile int count_cdouble; |
48 | volatile int count_cfloat; |
49 | volatile int count_cldouble; |
50 | |
51 | #define NCALLS 158 |
52 | #define NCALLS_INT 4 |
53 | #define NCCALLS 47 |
54 | |
55 | static int |
56 | do_test (void) |
57 | { |
58 | int result = 0; |
59 | |
60 | count_float = count_double = count_ldouble = 0; |
61 | count_cfloat = count_cdouble = count_cldouble = 0; |
62 | compile_test (); |
63 | if (count_float != 0 || count_cfloat != 0) |
64 | { |
65 | puts (s: "float function called for double test" ); |
66 | result = 1; |
67 | } |
68 | if (count_ldouble != 0 || count_cldouble != 0) |
69 | { |
70 | puts (s: "long double function called for double test" ); |
71 | result = 1; |
72 | } |
73 | if (count_double < NCALLS + NCALLS_INT) |
74 | { |
75 | printf (format: "double functions not called often enough (%d)\n" , |
76 | count_double); |
77 | result = 1; |
78 | } |
79 | else if (count_double > NCALLS + NCALLS_INT) |
80 | { |
81 | printf (format: "double functions called too often (%d)\n" , |
82 | count_double); |
83 | result = 1; |
84 | } |
85 | if (count_cdouble < NCCALLS) |
86 | { |
87 | printf (format: "double complex functions not called often enough (%d)\n" , |
88 | count_cdouble); |
89 | result = 1; |
90 | } |
91 | else if (count_cdouble > NCCALLS) |
92 | { |
93 | printf (format: "double complex functions called too often (%d)\n" , |
94 | count_cdouble); |
95 | result = 1; |
96 | } |
97 | |
98 | count_float = count_double = count_ldouble = 0; |
99 | count_cfloat = count_cdouble = count_cldouble = 0; |
100 | compile_testf (); |
101 | if (count_double != 0 || count_cdouble != 0) |
102 | { |
103 | puts (s: "double function called for float test" ); |
104 | result = 1; |
105 | } |
106 | if (count_ldouble != 0 || count_cldouble != 0) |
107 | { |
108 | puts (s: "long double function called for float test" ); |
109 | result = 1; |
110 | } |
111 | if (count_float < NCALLS) |
112 | { |
113 | printf (format: "float functions not called often enough (%d)\n" , count_float); |
114 | result = 1; |
115 | } |
116 | else if (count_float > NCALLS) |
117 | { |
118 | printf (format: "float functions called too often (%d)\n" , |
119 | count_double); |
120 | result = 1; |
121 | } |
122 | if (count_cfloat < NCCALLS) |
123 | { |
124 | printf (format: "float complex functions not called often enough (%d)\n" , |
125 | count_cfloat); |
126 | result = 1; |
127 | } |
128 | else if (count_cfloat > NCCALLS) |
129 | { |
130 | printf (format: "float complex functions called too often (%d)\n" , |
131 | count_cfloat); |
132 | result = 1; |
133 | } |
134 | |
135 | #if LDBL_MANT_DIG > DBL_MANT_DIG |
136 | count_float = count_double = count_ldouble = 0; |
137 | count_cfloat = count_cdouble = count_cldouble = 0; |
138 | compile_testl (); |
139 | if (count_float != 0 || count_cfloat != 0) |
140 | { |
141 | puts (s: "float function called for long double test" ); |
142 | result = 1; |
143 | } |
144 | if (count_double != 0 || count_cdouble != 0) |
145 | { |
146 | puts (s: "double function called for long double test" ); |
147 | result = 1; |
148 | } |
149 | if (count_ldouble < NCALLS) |
150 | { |
151 | printf (format: "long double functions not called often enough (%d)\n" , |
152 | count_ldouble); |
153 | result = 1; |
154 | } |
155 | else if (count_ldouble > NCALLS) |
156 | { |
157 | printf (format: "long double functions called too often (%d)\n" , |
158 | count_double); |
159 | result = 1; |
160 | } |
161 | if (count_cldouble < NCCALLS) |
162 | { |
163 | printf (format: "long double complex functions not called often enough (%d)\n" , |
164 | count_cldouble); |
165 | result = 1; |
166 | } |
167 | else if (count_cldouble > NCCALLS) |
168 | { |
169 | printf (format: "long double complex functions called too often (%d)\n" , |
170 | count_cldouble); |
171 | result = 1; |
172 | } |
173 | #endif |
174 | |
175 | return result; |
176 | } |
177 | |
178 | /* Now generate the three functions. */ |
179 | #define HAVE_MAIN |
180 | |
181 | #define F(name) name |
182 | #define TYPE double |
183 | #define TEST_INT 1 |
184 | #define x dx |
185 | #define y dy |
186 | #define z dz |
187 | #define count count_double |
188 | #define ccount count_cdouble |
189 | #include "test-tgmath.c" |
190 | |
191 | #define F(name) name##f |
192 | #define TYPE float |
193 | #define x fx |
194 | #define y fy |
195 | #define z fz |
196 | #define count count_float |
197 | #define ccount count_cfloat |
198 | #include "test-tgmath.c" |
199 | |
200 | #if LDBL_MANT_DIG > DBL_MANT_DIG |
201 | #define F(name) name##l |
202 | #define TYPE long double |
203 | #define x lx |
204 | #define y ly |
205 | #define z lz |
206 | #define count count_ldouble |
207 | #define ccount count_cldouble |
208 | #include "test-tgmath.c" |
209 | #endif |
210 | |
211 | #define TEST_FUNCTION do_test () |
212 | #include "../test-skeleton.c" |
213 | |
214 | #else |
215 | |
216 | #ifdef DEBUG |
217 | #define P() puts (__FUNCTION__) |
218 | #else |
219 | #define P() |
220 | #endif |
221 | |
222 | static void |
223 | F(compile_test) (void) |
224 | { |
225 | TYPE a, b, c = 1.0; |
226 | complex TYPE d; |
227 | int i = 2; |
228 | int saved_count; |
229 | long int j; |
230 | long long int k; |
231 | intmax_t m; |
232 | uintmax_t um; |
233 | |
234 | a = cos (cos (x)); |
235 | b = acos (acos (a)); |
236 | a = sin (sin (x)); |
237 | b = asin (asin (a)); |
238 | a = tan (tan (x)); |
239 | b = atan (atan (a)); |
240 | c = atan2 (atan2 (a, c), atan2 (b, x)); |
241 | a = cosh (cosh (x)); |
242 | b = acosh (acosh (a)); |
243 | a = sinh (sinh (x)); |
244 | b = asinh (asinh (a)); |
245 | a = tanh (tanh (x)); |
246 | b = atanh (atanh (a)); |
247 | a = exp (exp (x)); |
248 | b = log (log (a)); |
249 | a = log10 (log10 (x)); |
250 | b = ldexp (ldexp (a, 1), 5); |
251 | a = frexp (frexp (x, &i), &i); |
252 | b = expm1 (expm1 (a)); |
253 | a = log1p (log1p (x)); |
254 | b = logb (logb (a)); |
255 | a = exp2 (exp2 (x)); |
256 | a = exp10 (exp10 (x)); |
257 | b = log2 (log2 (a)); |
258 | a = pow (pow (x, a), pow (c, b)); |
259 | b = sqrt (sqrt (a)); |
260 | a = hypot (hypot (x, b), hypot (c, a)); |
261 | b = cbrt (cbrt (a)); |
262 | a = ceil (ceil (x)); |
263 | b = fabs (fabs (a)); |
264 | a = floor (floor (x)); |
265 | b = fmod (fmod (a, b), fmod (c, x)); |
266 | a = nearbyint (nearbyint (x)); |
267 | b = round (round (a)); |
268 | c = roundeven (roundeven (a)); |
269 | a = trunc (trunc (x)); |
270 | b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i); |
271 | j = lrint (x) + lround (a); |
272 | k = llrint (b) + llround (c); |
273 | m = fromfp (a, FP_INT_UPWARD, 2) + fromfpx (b, FP_INT_DOWNWARD, 3); |
274 | um = ufromfp (c, FP_INT_TONEAREST, 4) + ufromfpx (a, FP_INT_TOWARDZERO, 5); |
275 | a = erf (erf (x)); |
276 | b = erfc (erfc (a)); |
277 | a = tgamma (tgamma (x)); |
278 | b = lgamma (lgamma (a)); |
279 | a = rint (rint (x)); |
280 | b = nextafter (nextafter (a, b), nextafter (c, x)); |
281 | a = nextdown (nextdown (a)); |
282 | b = nexttoward (nexttoward (x, a), c); |
283 | a = nextup (nextup (a)); |
284 | b = remainder (remainder (a, b), remainder (c, x)); |
285 | a = scalb (scalb (x, a), (TYPE) (6)); |
286 | k = scalbn (a, 7) + scalbln (c, 10l); |
287 | i = ilogb (x); |
288 | j = llogb (x); |
289 | a = fdim (fdim (x, a), fdim (c, b)); |
290 | b = fmax (fmax (a, x), fmax (c, b)); |
291 | a = fmin (fmin (x, a), fmin (c, b)); |
292 | b = fmaxmag (fmaxmag (a, x), fmaxmag (c, b)); |
293 | a = fminmag (fminmag (x, a), fminmag (c, b)); |
294 | b = fmaximum (fmaximum (a, x), fmaximum (c, b)); |
295 | a = fminimum (fminimum (x, a), fminimum (c, b)); |
296 | b = fmaximum_num (fmaximum_num (a, x), fmaximum_num (c, b)); |
297 | a = fminimum_num (fminimum_num (x, a), fminimum_num (c, b)); |
298 | b = fmaximum_mag (fmaximum_mag (a, x), fmaximum_mag (c, b)); |
299 | a = fminimum_mag (fminimum_mag (x, a), fminimum_mag (c, b)); |
300 | b = fmaximum_mag_num (fmaximum_mag_num (a, x), fmaximum_mag_num (c, b)); |
301 | a = fminimum_mag_num (fminimum_mag_num (x, a), fminimum_mag_num (c, b)); |
302 | b = fma (sin (a), sin (x), sin (c)); |
303 | |
304 | #ifdef TEST_INT |
305 | a = atan2 (i, b); |
306 | b = remquo (i, a, &i); |
307 | c = fma (i, b, i); |
308 | a = pow (i, c); |
309 | #endif |
310 | x = a + b + c + i + j + k + m + um; |
311 | |
312 | saved_count = count; |
313 | if (ccount != 0) |
314 | ccount = -10000; |
315 | |
316 | d = cos (cos (z)); |
317 | z = acos (acos (d)); |
318 | d = sin (sin (z)); |
319 | z = asin (asin (d)); |
320 | d = tan (tan (z)); |
321 | z = atan (atan (d)); |
322 | d = cosh (cosh (z)); |
323 | z = acosh (acosh (d)); |
324 | d = sinh (sinh (z)); |
325 | z = asinh (asinh (d)); |
326 | d = tanh (tanh (z)); |
327 | z = atanh (atanh (d)); |
328 | d = exp (exp (z)); |
329 | z = log (log (d)); |
330 | d = sqrt (sqrt (z)); |
331 | z = conj (conj (d)); |
332 | d = fabs (conj (a)); |
333 | z = pow (pow (a, d), pow (b, z)); |
334 | d = cproj (cproj (z)); |
335 | z += fabs (cproj (a)); |
336 | a = carg (carg (z)); |
337 | b = creal (creal (d)); |
338 | c = cimag (cimag (z)); |
339 | x += a + b + c + i + j + k; |
340 | z += d; |
341 | |
342 | if (saved_count != count) |
343 | count = -10000; |
344 | |
345 | if (0) |
346 | { |
347 | a = cos (y); |
348 | a = acos (y); |
349 | a = sin (y); |
350 | a = asin (y); |
351 | a = tan (y); |
352 | a = atan (y); |
353 | a = atan2 (y, y); |
354 | a = cosh (y); |
355 | a = acosh (y); |
356 | a = sinh (y); |
357 | a = asinh (y); |
358 | a = tanh (y); |
359 | a = atanh (y); |
360 | a = exp (y); |
361 | a = log (y); |
362 | a = log10 (y); |
363 | a = ldexp (y, 5); |
364 | a = frexp (y, &i); |
365 | a = expm1 (y); |
366 | a = log1p (y); |
367 | a = logb (y); |
368 | a = exp2 (y); |
369 | a = exp10 (y); |
370 | a = log2 (y); |
371 | a = pow (y, y); |
372 | a = sqrt (y); |
373 | a = hypot (y, y); |
374 | a = cbrt (y); |
375 | a = ceil (y); |
376 | a = fabs (y); |
377 | a = floor (y); |
378 | a = fmod (y, y); |
379 | a = nearbyint (y); |
380 | a = round (y); |
381 | a = roundeven (y); |
382 | a = trunc (y); |
383 | a = remquo (y, y, &i); |
384 | j = lrint (y) + lround (y); |
385 | k = llrint (y) + llround (y); |
386 | m = fromfp (y, FP_INT_UPWARD, 6) + fromfpx (y, FP_INT_DOWNWARD, 7); |
387 | um = (ufromfp (y, FP_INT_TONEAREST, 8) |
388 | + ufromfpx (y, FP_INT_TOWARDZERO, 9)); |
389 | a = erf (y); |
390 | a = erfc (y); |
391 | a = tgamma (y); |
392 | a = lgamma (y); |
393 | a = rint (y); |
394 | a = nextafter (y, y); |
395 | a = nexttoward (y, y); |
396 | a = remainder (y, y); |
397 | a = scalb (y, (const TYPE) (6)); |
398 | k = scalbn (y, 7) + scalbln (y, 10l); |
399 | i = ilogb (y); |
400 | j = llogb (y); |
401 | a = fdim (y, y); |
402 | a = fmax (y, y); |
403 | a = fmin (y, y); |
404 | a = fmaxmag (y, y); |
405 | a = fminmag (y, y); |
406 | a = fmaximum (y, y); |
407 | a = fminimum (y, y); |
408 | a = fmaximum_num (y, y); |
409 | a = fminimum_num (y, y); |
410 | a = fmaximum_mag (y, y); |
411 | a = fminimum_mag (y, y); |
412 | a = fmaximum_mag_num (y, y); |
413 | a = fminimum_mag_num (y, y); |
414 | a = fma (y, y, y); |
415 | |
416 | #ifdef TEST_INT |
417 | a = atan2 (i, y); |
418 | a = remquo (i, y, &i); |
419 | a = fma (i, y, i); |
420 | a = pow (i, y); |
421 | #endif |
422 | |
423 | d = cos ((const complex TYPE) z); |
424 | d = acos ((const complex TYPE) z); |
425 | d = sin ((const complex TYPE) z); |
426 | d = asin ((const complex TYPE) z); |
427 | d = tan ((const complex TYPE) z); |
428 | d = atan ((const complex TYPE) z); |
429 | d = cosh ((const complex TYPE) z); |
430 | d = acosh ((const complex TYPE) z); |
431 | d = sinh ((const complex TYPE) z); |
432 | d = asinh ((const complex TYPE) z); |
433 | d = tanh ((const complex TYPE) z); |
434 | d = atanh ((const complex TYPE) z); |
435 | d = exp ((const complex TYPE) z); |
436 | d = log ((const complex TYPE) z); |
437 | d = sqrt ((const complex TYPE) z); |
438 | d = pow ((const complex TYPE) z, (const complex TYPE) z); |
439 | d = fabs ((const complex TYPE) z); |
440 | d = carg ((const complex TYPE) z); |
441 | d = creal ((const complex TYPE) z); |
442 | d = cimag ((const complex TYPE) z); |
443 | d = conj ((const complex TYPE) z); |
444 | d = cproj ((const complex TYPE) z); |
445 | } |
446 | } |
447 | #undef x |
448 | #undef y |
449 | #undef z |
450 | |
451 | |
452 | TYPE |
453 | (F(cos)) (TYPE x) |
454 | { |
455 | ++count; |
456 | P (); |
457 | return x; |
458 | } |
459 | |
460 | TYPE |
461 | (F(acos)) (TYPE x) |
462 | { |
463 | ++count; |
464 | P (); |
465 | return x; |
466 | } |
467 | |
468 | TYPE |
469 | (F(sin)) (TYPE x) |
470 | { |
471 | ++count; |
472 | P (); |
473 | return x; |
474 | } |
475 | |
476 | TYPE |
477 | (F(asin)) (TYPE x) |
478 | { |
479 | ++count; |
480 | P (); |
481 | return x; |
482 | } |
483 | |
484 | TYPE |
485 | (F(tan)) (TYPE x) |
486 | { |
487 | ++count; |
488 | P (); |
489 | return x; |
490 | } |
491 | |
492 | TYPE |
493 | (F(atan)) (TYPE x) |
494 | { |
495 | ++count; |
496 | P (); |
497 | return x; |
498 | } |
499 | |
500 | TYPE |
501 | (F(atan2)) (TYPE x, TYPE y) |
502 | { |
503 | ++count; |
504 | P (); |
505 | return x + y; |
506 | } |
507 | |
508 | TYPE |
509 | (F(cosh)) (TYPE x) |
510 | { |
511 | ++count; |
512 | P (); |
513 | return x; |
514 | } |
515 | |
516 | TYPE |
517 | (F(acosh)) (TYPE x) |
518 | { |
519 | ++count; |
520 | P (); |
521 | return x; |
522 | } |
523 | |
524 | TYPE |
525 | (F(sinh)) (TYPE x) |
526 | { |
527 | ++count; |
528 | P (); |
529 | return x; |
530 | } |
531 | |
532 | TYPE |
533 | (F(asinh)) (TYPE x) |
534 | { |
535 | ++count; |
536 | P (); |
537 | return x; |
538 | } |
539 | |
540 | TYPE |
541 | (F(tanh)) (TYPE x) |
542 | { |
543 | ++count; |
544 | P (); |
545 | return x; |
546 | } |
547 | |
548 | TYPE |
549 | (F(atanh)) (TYPE x) |
550 | { |
551 | ++count; |
552 | P (); |
553 | return x; |
554 | } |
555 | |
556 | TYPE |
557 | (F(exp)) (TYPE x) |
558 | { |
559 | ++count; |
560 | P (); |
561 | return x; |
562 | } |
563 | |
564 | TYPE |
565 | (F(log)) (TYPE x) |
566 | { |
567 | ++count; |
568 | P (); |
569 | return x; |
570 | } |
571 | |
572 | TYPE |
573 | (F(log10)) (TYPE x) |
574 | { |
575 | ++count; |
576 | P (); |
577 | return x; |
578 | } |
579 | |
580 | TYPE |
581 | (F(ldexp)) (TYPE x, int y) |
582 | { |
583 | ++count; |
584 | P (); |
585 | return x + y; |
586 | } |
587 | |
588 | TYPE |
589 | (F(frexp)) (TYPE x, int *y) |
590 | { |
591 | ++count; |
592 | P (); |
593 | return x + *y; |
594 | } |
595 | |
596 | TYPE |
597 | (F(expm1)) (TYPE x) |
598 | { |
599 | ++count; |
600 | P (); |
601 | return x; |
602 | } |
603 | |
604 | TYPE |
605 | (F(log1p)) (TYPE x) |
606 | { |
607 | ++count; |
608 | P (); |
609 | return x; |
610 | } |
611 | |
612 | TYPE |
613 | (F(logb)) (TYPE x) |
614 | { |
615 | ++count; |
616 | P (); |
617 | return x; |
618 | } |
619 | |
620 | TYPE |
621 | (F(exp10)) (TYPE x) |
622 | { |
623 | ++count; |
624 | P (); |
625 | return x; |
626 | } |
627 | |
628 | TYPE |
629 | (F(exp2)) (TYPE x) |
630 | { |
631 | ++count; |
632 | P (); |
633 | return x; |
634 | } |
635 | |
636 | TYPE |
637 | (F(log2)) (TYPE x) |
638 | { |
639 | ++count; |
640 | P (); |
641 | return x; |
642 | } |
643 | |
644 | TYPE |
645 | (F(pow)) (TYPE x, TYPE y) |
646 | { |
647 | ++count; |
648 | P (); |
649 | return x + y; |
650 | } |
651 | |
652 | TYPE |
653 | (F(sqrt)) (TYPE x) |
654 | { |
655 | ++count; |
656 | P (); |
657 | return x; |
658 | } |
659 | |
660 | TYPE |
661 | (F(hypot)) (TYPE x, TYPE y) |
662 | { |
663 | ++count; |
664 | P (); |
665 | return x + y; |
666 | } |
667 | |
668 | TYPE |
669 | (F(cbrt)) (TYPE x) |
670 | { |
671 | ++count; |
672 | P (); |
673 | return x; |
674 | } |
675 | |
676 | TYPE |
677 | (F(ceil)) (TYPE x) |
678 | { |
679 | ++count; |
680 | P (); |
681 | return x; |
682 | } |
683 | |
684 | TYPE |
685 | (F(fabs)) (TYPE x) |
686 | { |
687 | ++count; |
688 | P (); |
689 | return x; |
690 | } |
691 | |
692 | TYPE |
693 | (F(floor)) (TYPE x) |
694 | { |
695 | ++count; |
696 | P (); |
697 | return x; |
698 | } |
699 | |
700 | TYPE |
701 | (F(fmod)) (TYPE x, TYPE y) |
702 | { |
703 | ++count; |
704 | P (); |
705 | return x + y; |
706 | } |
707 | |
708 | TYPE |
709 | (F(nearbyint)) (TYPE x) |
710 | { |
711 | ++count; |
712 | P (); |
713 | return x; |
714 | } |
715 | |
716 | TYPE |
717 | (F(round)) (TYPE x) |
718 | { |
719 | ++count; |
720 | P (); |
721 | return x; |
722 | } |
723 | |
724 | TYPE |
725 | (F(roundeven)) (TYPE x) |
726 | { |
727 | ++count; |
728 | P (); |
729 | return x; |
730 | } |
731 | |
732 | TYPE |
733 | (F(trunc)) (TYPE x) |
734 | { |
735 | ++count; |
736 | P (); |
737 | return x; |
738 | } |
739 | |
740 | TYPE |
741 | (F(remquo)) (TYPE x, TYPE y, int *i) |
742 | { |
743 | ++count; |
744 | P (); |
745 | return x + y + *i; |
746 | } |
747 | |
748 | long int |
749 | (F(lrint)) (TYPE x) |
750 | { |
751 | ++count; |
752 | P (); |
753 | return x; |
754 | } |
755 | |
756 | long int |
757 | (F(lround)) (TYPE x) |
758 | { |
759 | ++count; |
760 | P (); |
761 | return x; |
762 | } |
763 | |
764 | long long int |
765 | (F(llrint)) (TYPE x) |
766 | { |
767 | ++count; |
768 | P (); |
769 | return x; |
770 | } |
771 | |
772 | long long int |
773 | (F(llround)) (TYPE x) |
774 | { |
775 | ++count; |
776 | P (); |
777 | return x; |
778 | } |
779 | |
780 | intmax_t |
781 | (F(fromfp)) (TYPE x, int round, unsigned int width) |
782 | { |
783 | ++count; |
784 | P (); |
785 | return x; |
786 | } |
787 | |
788 | intmax_t |
789 | (F(fromfpx)) (TYPE x, int round, unsigned int width) |
790 | { |
791 | ++count; |
792 | P (); |
793 | return x; |
794 | } |
795 | |
796 | uintmax_t |
797 | (F(ufromfp)) (TYPE x, int round, unsigned int width) |
798 | { |
799 | ++count; |
800 | P (); |
801 | return x; |
802 | } |
803 | |
804 | uintmax_t |
805 | (F(ufromfpx)) (TYPE x, int round, unsigned int width) |
806 | { |
807 | ++count; |
808 | P (); |
809 | return x; |
810 | } |
811 | |
812 | TYPE |
813 | (F(erf)) (TYPE x) |
814 | { |
815 | ++count; |
816 | P (); |
817 | return x; |
818 | } |
819 | |
820 | TYPE |
821 | (F(erfc)) (TYPE x) |
822 | { |
823 | ++count; |
824 | P (); |
825 | return x; |
826 | } |
827 | |
828 | TYPE |
829 | (F(tgamma)) (TYPE x) |
830 | { |
831 | ++count; |
832 | P (); |
833 | return x; |
834 | } |
835 | |
836 | TYPE |
837 | (F(lgamma)) (TYPE x) |
838 | { |
839 | ++count; |
840 | P (); |
841 | return x; |
842 | } |
843 | |
844 | TYPE |
845 | (F(rint)) (TYPE x) |
846 | { |
847 | ++count; |
848 | P (); |
849 | return x; |
850 | } |
851 | |
852 | TYPE |
853 | (F(nextafter)) (TYPE x, TYPE y) |
854 | { |
855 | ++count; |
856 | P (); |
857 | return x + y; |
858 | } |
859 | |
860 | TYPE |
861 | (F(nextdown)) (TYPE x) |
862 | { |
863 | ++count; |
864 | P (); |
865 | return x; |
866 | } |
867 | |
868 | TYPE |
869 | (F(nexttoward)) (TYPE x, long double y) |
870 | { |
871 | ++count; |
872 | P (); |
873 | return x + y; |
874 | } |
875 | |
876 | TYPE |
877 | (F(nextup)) (TYPE x) |
878 | { |
879 | ++count; |
880 | P (); |
881 | return x; |
882 | } |
883 | |
884 | TYPE |
885 | (F(remainder)) (TYPE x, TYPE y) |
886 | { |
887 | ++count; |
888 | P (); |
889 | return x + y; |
890 | } |
891 | |
892 | TYPE |
893 | (F(scalb)) (TYPE x, TYPE y) |
894 | { |
895 | ++count; |
896 | P (); |
897 | return x + y; |
898 | } |
899 | |
900 | TYPE |
901 | (F(scalbn)) (TYPE x, int y) |
902 | { |
903 | ++count; |
904 | P (); |
905 | return x + y; |
906 | } |
907 | |
908 | TYPE |
909 | (F(scalbln)) (TYPE x, long int y) |
910 | { |
911 | ++count; |
912 | P (); |
913 | return x + y; |
914 | } |
915 | |
916 | int |
917 | (F(ilogb)) (TYPE x) |
918 | { |
919 | ++count; |
920 | P (); |
921 | return x; |
922 | } |
923 | |
924 | long int |
925 | (F(llogb)) (TYPE x) |
926 | { |
927 | ++count; |
928 | P (); |
929 | return x; |
930 | } |
931 | |
932 | TYPE |
933 | (F(fdim)) (TYPE x, TYPE y) |
934 | { |
935 | ++count; |
936 | P (); |
937 | return x + y; |
938 | } |
939 | |
940 | TYPE |
941 | (F(fmin)) (TYPE x, TYPE y) |
942 | { |
943 | ++count; |
944 | P (); |
945 | return x + y; |
946 | } |
947 | |
948 | TYPE |
949 | (F(fmax)) (TYPE x, TYPE y) |
950 | { |
951 | ++count; |
952 | P (); |
953 | return x + y; |
954 | } |
955 | |
956 | TYPE |
957 | (F(fminmag)) (TYPE x, TYPE y) |
958 | { |
959 | ++count; |
960 | P (); |
961 | return x + y; |
962 | } |
963 | |
964 | TYPE |
965 | (F(fmaxmag)) (TYPE x, TYPE y) |
966 | { |
967 | ++count; |
968 | P (); |
969 | return x + y; |
970 | } |
971 | |
972 | TYPE |
973 | (F(fminimum)) (TYPE x, TYPE y) |
974 | { |
975 | ++count; |
976 | P (); |
977 | return x + y; |
978 | } |
979 | |
980 | TYPE |
981 | (F(fmaximum)) (TYPE x, TYPE y) |
982 | { |
983 | ++count; |
984 | P (); |
985 | return x + y; |
986 | } |
987 | |
988 | TYPE |
989 | (F(fminimum_num)) (TYPE x, TYPE y) |
990 | { |
991 | ++count; |
992 | P (); |
993 | return x + y; |
994 | } |
995 | |
996 | TYPE |
997 | (F(fmaximum_num)) (TYPE x, TYPE y) |
998 | { |
999 | ++count; |
1000 | P (); |
1001 | return x + y; |
1002 | } |
1003 | |
1004 | TYPE |
1005 | (F(fminimum_mag)) (TYPE x, TYPE y) |
1006 | { |
1007 | ++count; |
1008 | P (); |
1009 | return x + y; |
1010 | } |
1011 | |
1012 | TYPE |
1013 | (F(fmaximum_mag)) (TYPE x, TYPE y) |
1014 | { |
1015 | ++count; |
1016 | P (); |
1017 | return x + y; |
1018 | } |
1019 | |
1020 | TYPE |
1021 | (F(fminimum_mag_num)) (TYPE x, TYPE y) |
1022 | { |
1023 | ++count; |
1024 | P (); |
1025 | return x + y; |
1026 | } |
1027 | |
1028 | TYPE |
1029 | (F(fmaximum_mag_num)) (TYPE x, TYPE y) |
1030 | { |
1031 | ++count; |
1032 | P (); |
1033 | return x + y; |
1034 | } |
1035 | |
1036 | TYPE |
1037 | (F(fma)) (TYPE x, TYPE y, TYPE z) |
1038 | { |
1039 | ++count; |
1040 | P (); |
1041 | return x + y + z; |
1042 | } |
1043 | |
1044 | complex TYPE |
1045 | (F(cacos)) (complex TYPE x) |
1046 | { |
1047 | ++ccount; |
1048 | P (); |
1049 | return x; |
1050 | } |
1051 | |
1052 | complex TYPE |
1053 | (F(casin)) (complex TYPE x) |
1054 | { |
1055 | ++ccount; |
1056 | P (); |
1057 | return x; |
1058 | } |
1059 | |
1060 | complex TYPE |
1061 | (F(catan)) (complex TYPE x) |
1062 | { |
1063 | ++ccount; |
1064 | P (); |
1065 | return x; |
1066 | } |
1067 | |
1068 | complex TYPE |
1069 | (F(ccos)) (complex TYPE x) |
1070 | { |
1071 | ++ccount; |
1072 | P (); |
1073 | return x; |
1074 | } |
1075 | |
1076 | complex TYPE |
1077 | (F(csin)) (complex TYPE x) |
1078 | { |
1079 | ++ccount; |
1080 | P (); |
1081 | return x; |
1082 | } |
1083 | |
1084 | complex TYPE |
1085 | (F(ctan)) (complex TYPE x) |
1086 | { |
1087 | ++ccount; |
1088 | P (); |
1089 | return x; |
1090 | } |
1091 | |
1092 | complex TYPE |
1093 | (F(cacosh)) (complex TYPE x) |
1094 | { |
1095 | ++ccount; |
1096 | P (); |
1097 | return x; |
1098 | } |
1099 | |
1100 | complex TYPE |
1101 | (F(casinh)) (complex TYPE x) |
1102 | { |
1103 | ++ccount; |
1104 | P (); |
1105 | return x; |
1106 | } |
1107 | |
1108 | complex TYPE |
1109 | (F(catanh)) (complex TYPE x) |
1110 | { |
1111 | ++ccount; |
1112 | P (); |
1113 | return x; |
1114 | } |
1115 | |
1116 | complex TYPE |
1117 | (F(ccosh)) (complex TYPE x) |
1118 | { |
1119 | ++ccount; |
1120 | P (); |
1121 | return x; |
1122 | } |
1123 | |
1124 | complex TYPE |
1125 | (F(csinh)) (complex TYPE x) |
1126 | { |
1127 | ++ccount; |
1128 | P (); |
1129 | return x; |
1130 | } |
1131 | |
1132 | complex TYPE |
1133 | (F(ctanh)) (complex TYPE x) |
1134 | { |
1135 | ++ccount; |
1136 | P (); |
1137 | return x; |
1138 | } |
1139 | |
1140 | complex TYPE |
1141 | (F(cexp)) (complex TYPE x) |
1142 | { |
1143 | ++ccount; |
1144 | P (); |
1145 | return x; |
1146 | } |
1147 | |
1148 | complex TYPE |
1149 | (F(clog)) (complex TYPE x) |
1150 | { |
1151 | ++ccount; |
1152 | P (); |
1153 | return x; |
1154 | } |
1155 | |
1156 | complex TYPE |
1157 | (F(csqrt)) (complex TYPE x) |
1158 | { |
1159 | ++ccount; |
1160 | P (); |
1161 | return x; |
1162 | } |
1163 | |
1164 | complex TYPE |
1165 | (F(cpow)) (complex TYPE x, complex TYPE y) |
1166 | { |
1167 | ++ccount; |
1168 | P (); |
1169 | return x + y; |
1170 | } |
1171 | |
1172 | TYPE |
1173 | (F(cabs)) (complex TYPE x) |
1174 | { |
1175 | ++ccount; |
1176 | P (); |
1177 | return x; |
1178 | } |
1179 | |
1180 | TYPE |
1181 | (F(carg)) (complex TYPE x) |
1182 | { |
1183 | ++ccount; |
1184 | P (); |
1185 | return x; |
1186 | } |
1187 | |
1188 | TYPE |
1189 | (F(creal)) (complex TYPE x) |
1190 | { |
1191 | ++ccount; |
1192 | P (); |
1193 | return __real__ x; |
1194 | } |
1195 | |
1196 | TYPE |
1197 | (F(cimag)) (complex TYPE x) |
1198 | { |
1199 | ++ccount; |
1200 | P (); |
1201 | return __imag__ x; |
1202 | } |
1203 | |
1204 | complex TYPE |
1205 | (F(conj)) (complex TYPE x) |
1206 | { |
1207 | ++ccount; |
1208 | P (); |
1209 | return x; |
1210 | } |
1211 | |
1212 | complex TYPE |
1213 | (F(cproj)) (complex TYPE x) |
1214 | { |
1215 | ++ccount; |
1216 | P (); |
1217 | return x; |
1218 | } |
1219 | |
1220 | #undef F |
1221 | #undef TYPE |
1222 | #undef count |
1223 | #undef ccount |
1224 | #undef TEST_INT |
1225 | #endif |
1226 | |