Print this page
10881 more C99 math macros should be compiler builtins
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/head/iso/math_c99.h
+++ new/usr/src/head/iso/math_c99.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
23 23 */
24 24 /*
25 25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
26 26 * Use is subject to license terms.
27 27 */
28 28
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
29 29 #ifndef _ISO_MATH_C99_H
30 30 #define _ISO_MATH_C99_H
31 31
32 32 #include <sys/isa_defs.h>
33 33 #include <sys/feature_tests.h>
34 34
35 35 #ifdef __cplusplus
36 36 extern "C" {
37 37 #endif
38 38
39 +#undef FP_ZERO
40 +#define FP_ZERO 0
41 +#undef FP_SUBNORMAL
42 +#define FP_SUBNORMAL 1
43 +#undef FP_NORMAL
44 +#define FP_NORMAL 2
45 +#undef FP_INFINITE
46 +#define FP_INFINITE 3
47 +#undef FP_NAN
48 +#define FP_NAN 4
49 +
39 50 #if defined(_STDC_C99) || _XOPEN_SOURCE - 0 >= 600 || defined(__C99FEATURES__)
40 51 #if defined(__GNUC__)
41 52 #undef HUGE_VAL
42 53 #define HUGE_VAL (__builtin_huge_val())
43 54 #undef HUGE_VALF
44 55 #define HUGE_VALF (__builtin_huge_valf())
45 56 #undef HUGE_VALL
46 57 #define HUGE_VALL (__builtin_huge_vall())
47 58 #undef INFINITY
48 59 #define INFINITY (__builtin_inff())
49 60 #undef NAN
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
50 61 #define NAN (__builtin_nanf(""))
51 62
52 63 /*
53 64 * C99 7.12.3 classification macros
54 65 */
55 66 #undef isnan
56 67 #undef isinf
57 68 #if __GNUC__ >= 4
58 69 #define isnan(x) __builtin_isnan(x)
59 70 #define isinf(x) __builtin_isinf(x)
60 -#else
71 +#define fpclassify(x) __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, \
72 + FP_SUBNORMAL, FP_ZERO, x)
73 +#define isfinite(x) __builtin_isfinite(x)
74 +#define isnormal(x) __builtin_isnormal(x)
75 +#define signbit(x) __builtin_signbit(x)
76 +#else /* __GNUC__ >= 4 */
61 77 #define isnan(x) __extension__( \
62 78 { __typeof(x) __x_n = (x); \
63 79 __builtin_isunordered(__x_n, __x_n); })
64 80 #define isinf(x) __extension__( \
65 81 { __typeof(x) __x_i = (x); \
66 82 __x_i == (__typeof(__x_i)) INFINITY || \
67 83 __x_i == (__typeof(__x_i)) (-INFINITY); })
68 -#endif
69 84 #undef isfinite
70 85 #define isfinite(x) __extension__( \
71 86 { __typeof(x) __x_f = (x); \
72 87 !isnan(__x_f) && !isinf(__x_f); })
73 88 #undef isnormal
74 89 #define isnormal(x) __extension__( \
75 90 { __typeof(x) __x_r = (x); isfinite(__x_r) && \
76 91 (sizeof (__x_r) == sizeof (float) ? \
77 92 __builtin_fabsf(__x_r) >= __FLT_MIN__ : \
78 93 sizeof (__x_r) == sizeof (double) ? \
79 94 __builtin_fabs(__x_r) >= __DBL_MIN__ : \
80 95 __builtin_fabsl(__x_r) >= __LDBL_MIN__); })
81 96 #undef fpclassify
82 97 #define fpclassify(x) __extension__( \
83 98 { __typeof(x) __x_c = (x); \
84 99 isnan(__x_c) ? FP_NAN : \
85 100 isinf(__x_c) ? FP_INFINITE : \
86 101 isnormal(__x_c) ? FP_NORMAL : \
87 102 __x_c == (__typeof(__x_c)) 0 ? FP_ZERO : \
88 103 FP_SUBNORMAL; })
89 104 #undef signbit
90 105 #if defined(_BIG_ENDIAN)
91 106 #define signbit(x) __extension__( \
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
92 107 { __typeof(x) __x_s = (x); \
93 108 (int)(*(unsigned *)&__x_s >> 31); })
94 109 #elif defined(_LITTLE_ENDIAN)
95 110 #define signbit(x) __extension__( \
96 111 { __typeof(x) __x_s = (x); \
97 112 (sizeof (__x_s) == sizeof (float) ? \
98 113 (int)(*(unsigned *)&__x_s >> 31) : \
99 114 sizeof (__x_s) == sizeof (double) ? \
100 115 (int)(((unsigned *)&__x_s)[1] >> 31) : \
101 116 (int)(((unsigned short *)&__x_s)[4] >> 15)); })
102 -#endif
117 +#endif /* defined(_BIG_ENDIAN) */
118 +#endif /* __GNUC__ >= 4 */
103 119
104 120 /*
105 121 * C99 7.12.14 comparison macros
106 122 */
107 123 #undef isgreater
108 124 #define isgreater(x, y) __builtin_isgreater(x, y)
109 125 #undef isgreaterequal
110 126 #define isgreaterequal(x, y) __builtin_isgreaterequal(x, y)
111 127 #undef isless
112 128 #define isless(x, y) __builtin_isless(x, y)
113 129 #undef islessequal
114 130 #define islessequal(x, y) __builtin_islessequal(x, y)
115 131 #undef islessgreater
116 132 #define islessgreater(x, y) __builtin_islessgreater(x, y)
117 133 #undef isunordered
118 134 #define isunordered(x, y) __builtin_isunordered(x, y)
119 135 #else /* defined(__GNUC__) */
120 136 #undef HUGE_VAL
121 137 #define HUGE_VAL __builtin_huge_val
122 138 #undef HUGE_VALF
123 139 #define HUGE_VALF __builtin_huge_valf
124 140 #undef HUGE_VALL
125 141 #define HUGE_VALL __builtin_huge_vall
126 142 #undef INFINITY
127 143 #define INFINITY __builtin_infinity
128 144 #undef NAN
129 145 #define NAN __builtin_nan
130 146
131 147 /*
132 148 * C99 7.12.3 classification macros
133 149 */
134 150 #undef fpclassify
135 151 #define fpclassify(x) __builtin_fpclassify(x)
136 152 #undef isfinite
137 153 #define isfinite(x) __builtin_isfinite(x)
138 154 #undef isinf
139 155 #define isinf(x) __builtin_isinf(x)
140 156 #undef isnan
141 157 #define isnan(x) __builtin_isnan(x)
142 158 #undef isnormal
143 159 #define isnormal(x) __builtin_isnormal(x)
144 160 #undef signbit
145 161 #define signbit(x) __builtin_signbit(x)
146 162
147 163 /*
148 164 * C99 7.12.14 comparison macros
149 165 */
150 166 #undef isgreater
151 167 #define isgreater(x, y) ((x) __builtin_isgreater(y))
152 168 #undef isgreaterequal
153 169 #define isgreaterequal(x, y) ((x) __builtin_isgreaterequal(y))
154 170 #undef isless
155 171 #define isless(x, y) ((x) __builtin_isless(y))
156 172 #undef islessequal
157 173 #define islessequal(x, y) ((x) __builtin_islessequal(y))
158 174 #undef islessgreater
159 175 #define islessgreater(x, y) ((x) __builtin_islessgreater(y))
160 176 #undef isunordered
161 177 #define isunordered(x, y) ((x) __builtin_isunordered(y))
162 178 #endif /* defined(__GNUC__) */
163 179 #endif /* defined(_STDC_C99) || _XOPEN_SOURCE - 0 >= 600 || ... */
164 180
165 181 #if defined(__EXTENSIONS__) || defined(_STDC_C99) || \
166 182 (!defined(_STRICT_STDC) && !defined(__XOPEN_OR_POSIX)) || \
167 183 defined(__C99FEATURES__)
168 184 #if defined(__FLT_EVAL_METHOD__) && __FLT_EVAL_METHOD__ - 0 == 0
169 185 typedef float float_t;
170 186 typedef double double_t;
171 187 #elif __FLT_EVAL_METHOD__ - 0 == 1
172 188 typedef double float_t;
173 189 typedef double double_t;
|
↓ open down ↓ |
61 lines elided |
↑ open up ↑ |
174 190 #elif __FLT_EVAL_METHOD__ - 0 == 2
175 191 typedef long double float_t;
176 192 typedef long double double_t;
177 193 #elif defined(__sparc) || defined(__amd64)
178 194 typedef float float_t;
179 195 typedef double double_t;
180 196 #elif defined(__i386)
181 197 typedef long double float_t;
182 198 typedef long double double_t;
183 199 #endif
184 -
185 -#undef FP_ZERO
186 -#define FP_ZERO 0
187 -#undef FP_SUBNORMAL
188 -#define FP_SUBNORMAL 1
189 -#undef FP_NORMAL
190 -#define FP_NORMAL 2
191 -#undef FP_INFINITE
192 -#define FP_INFINITE 3
193 -#undef FP_NAN
194 -#define FP_NAN 4
195 200
196 201 #undef FP_ILOGB0
197 202 #define FP_ILOGB0 (-2147483647)
198 203 #undef FP_ILOGBNAN
199 204 #define FP_ILOGBNAN 2147483647
200 205
201 206 #undef MATH_ERRNO
202 207 #define MATH_ERRNO 1
203 208 #undef MATH_ERREXCEPT
204 209 #define MATH_ERREXCEPT 2
205 210 #undef math_errhandling
206 211 #define math_errhandling MATH_ERREXCEPT
207 212
208 213 extern double acosh(double);
209 214 extern double asinh(double);
210 215 extern double atanh(double);
211 216
212 217 extern double exp2(double);
213 218 extern double expm1(double);
214 219 extern int ilogb(double);
215 220 extern double log1p(double);
216 221 extern double log2(double);
217 222 extern double logb(double);
218 223 extern double scalbn(double, int);
219 224 extern double scalbln(double, long int);
220 225
221 226 extern double cbrt(double);
222 227 extern double hypot(double, double);
223 228
224 229 extern double erf(double);
225 230 extern double erfc(double);
226 231 extern double lgamma(double);
227 232 extern double tgamma(double);
228 233
229 234 extern double nearbyint(double);
230 235 extern double rint(double);
231 236 extern long int lrint(double);
232 237 extern double round(double);
233 238 extern long int lround(double);
234 239 extern double trunc(double);
235 240
236 241 extern double remainder(double, double);
237 242 extern double remquo(double, double, int *);
238 243
239 244 extern double copysign(double, double);
240 245 extern double nan(const char *);
241 246 extern double nextafter(double, double);
242 247 extern double nexttoward(double, long double);
243 248
244 249 extern double fdim(double, double);
245 250 extern double fmax(double, double);
246 251 extern double fmin(double, double);
247 252
248 253 extern double fma(double, double, double);
249 254
250 255 extern float acosf(float);
251 256 extern float asinf(float);
252 257 extern float atanf(float);
253 258 extern float atan2f(float, float);
254 259 extern float cosf(float);
255 260 extern float sinf(float);
256 261 extern float tanf(float);
257 262
258 263 extern float acoshf(float);
259 264 extern float asinhf(float);
260 265 extern float atanhf(float);
261 266 extern float coshf(float);
262 267 extern float sinhf(float);
263 268 extern float tanhf(float);
264 269
265 270 extern float expf(float);
266 271 extern float exp2f(float);
267 272 extern float expm1f(float);
268 273 extern float frexpf(float, int *);
269 274 extern int ilogbf(float);
270 275 extern float ldexpf(float, int);
271 276 extern float logf(float);
272 277 extern float log10f(float);
273 278 extern float log1pf(float);
274 279 extern float log2f(float);
275 280 extern float logbf(float);
276 281 extern float modff(float, float *);
277 282 extern float scalbnf(float, int);
278 283 extern float scalblnf(float, long int);
279 284
280 285 extern float cbrtf(float);
281 286 extern float fabsf(float);
282 287 extern float hypotf(float, float);
283 288 extern float powf(float, float);
284 289 extern float sqrtf(float);
285 290
286 291 extern float erff(float);
287 292 extern float erfcf(float);
288 293 extern float lgammaf(float);
289 294 extern float tgammaf(float);
290 295
291 296 extern float ceilf(float);
292 297 extern float floorf(float);
293 298 extern float nearbyintf(float);
294 299 extern float rintf(float);
295 300 extern long int lrintf(float);
296 301 extern float roundf(float);
297 302 extern long int lroundf(float);
298 303 extern float truncf(float);
299 304
300 305 extern float fmodf(float, float);
301 306 extern float remainderf(float, float);
302 307 extern float remquof(float, float, int *);
303 308
304 309 extern float copysignf(float, float);
305 310 extern float nanf(const char *);
306 311 extern float nextafterf(float, float);
307 312 extern float nexttowardf(float, long double);
308 313
309 314 extern float fdimf(float, float);
310 315 extern float fmaxf(float, float);
311 316 extern float fminf(float, float);
312 317
313 318 extern float fmaf(float, float, float);
314 319
315 320 extern long double acosl(long double);
316 321 extern long double asinl(long double);
317 322 extern long double atanl(long double);
318 323 extern long double atan2l(long double, long double);
319 324 extern long double cosl(long double);
320 325 extern long double sinl(long double);
321 326 extern long double tanl(long double);
322 327
323 328 extern long double acoshl(long double);
324 329 extern long double asinhl(long double);
325 330 extern long double atanhl(long double);
326 331 extern long double coshl(long double);
327 332 extern long double sinhl(long double);
328 333 extern long double tanhl(long double);
329 334
330 335 extern long double expl(long double);
331 336 extern long double exp2l(long double);
332 337 extern long double expm1l(long double);
333 338 extern long double frexpl(long double, int *);
334 339 extern int ilogbl(long double);
335 340 extern long double ldexpl(long double, int);
336 341 extern long double logl(long double);
337 342 extern long double log10l(long double);
338 343 extern long double log1pl(long double);
339 344 extern long double log2l(long double);
340 345 extern long double logbl(long double);
341 346 extern long double modfl(long double, long double *);
342 347 extern long double scalbnl(long double, int);
343 348 extern long double scalblnl(long double, long int);
344 349
345 350 extern long double cbrtl(long double);
346 351 extern long double fabsl(long double);
347 352 extern long double hypotl(long double, long double);
348 353 extern long double powl(long double, long double);
349 354 extern long double sqrtl(long double);
350 355
351 356 extern long double erfl(long double);
352 357 extern long double erfcl(long double);
353 358 extern long double lgammal(long double);
354 359 extern long double tgammal(long double);
355 360
356 361 extern long double ceill(long double);
357 362 extern long double floorl(long double);
358 363 extern long double nearbyintl(long double);
359 364 extern long double rintl(long double);
360 365 extern long int lrintl(long double);
361 366 extern long double roundl(long double);
362 367 extern long int lroundl(long double);
363 368 extern long double truncl(long double);
364 369
365 370 extern long double fmodl(long double, long double);
366 371 extern long double remainderl(long double, long double);
367 372 extern long double remquol(long double, long double, int *);
368 373
369 374 extern long double copysignl(long double, long double);
370 375 extern long double nanl(const char *);
371 376 extern long double nextafterl(long double, long double);
372 377 extern long double nexttowardl(long double, long double);
373 378
374 379 extern long double fdiml(long double, long double);
375 380 extern long double fmaxl(long double, long double);
376 381 extern long double fminl(long double, long double);
377 382
378 383 extern long double fmal(long double, long double, long double);
379 384
380 385 #if !defined(_STRICT_STDC) && !defined(_NO_LONGLONG) || defined(_STDC_C99) || \
381 386 defined(__C99FEATURES__)
382 387 extern long long int llrint(double);
383 388 extern long long int llround(double);
384 389
385 390 extern long long int llrintf(float);
386 391 extern long long int llroundf(float);
387 392
388 393 extern long long int llrintl(long double);
389 394 extern long long int llroundl(long double);
390 395 #endif
391 396
392 397 #if !defined(__cplusplus)
393 398 #pragma does_not_read_global_data(asinh, exp2, expm1)
394 399 #pragma does_not_read_global_data(ilogb, log2)
395 400 #pragma does_not_read_global_data(scalbn, scalbln, cbrt)
396 401 #pragma does_not_read_global_data(erf, erfc, tgamma)
397 402 #pragma does_not_read_global_data(nearbyint, rint, lrint, round, lround, trunc)
398 403 #pragma does_not_read_global_data(remquo)
399 404 #pragma does_not_read_global_data(copysign, nan, nexttoward)
400 405 #pragma does_not_read_global_data(fdim, fmax, fmin, fma)
401 406 #pragma does_not_write_global_data(asinh, exp2, expm1)
402 407 #pragma does_not_write_global_data(ilogb, log2)
403 408 #pragma does_not_write_global_data(scalbn, scalbln, cbrt)
404 409 #pragma does_not_write_global_data(erf, erfc, tgamma)
405 410 #pragma does_not_write_global_data(nearbyint, rint, lrint, round, lround, trunc)
406 411 #pragma does_not_write_global_data(copysign, nan, nexttoward)
407 412 #pragma does_not_write_global_data(fdim, fmax, fmin, fma)
408 413
409 414 #pragma does_not_read_global_data(acosf, asinf, atanf, atan2f)
410 415 #pragma does_not_read_global_data(cosf, sinf, tanf)
411 416 #pragma does_not_read_global_data(acoshf, asinhf, atanhf, coshf, sinhf, tanhf)
412 417 #pragma does_not_read_global_data(expf, exp2f, expm1f, frexpf, ilogbf, ldexpf)
413 418 #pragma does_not_read_global_data(logf, log10f, log1pf, log2f, logbf)
414 419 #pragma does_not_read_global_data(modff, scalbnf, scalblnf)
415 420 #pragma does_not_read_global_data(cbrtf, fabsf, hypotf, powf, sqrtf)
416 421 #pragma does_not_read_global_data(erff, erfcf, lgammaf, tgammaf)
417 422 #pragma does_not_read_global_data(ceilf, floorf, nearbyintf)
418 423 #pragma does_not_read_global_data(rintf, lrintf, roundf, lroundf, truncf)
419 424 #pragma does_not_read_global_data(fmodf, remainderf, remquof)
420 425 #pragma does_not_read_global_data(copysignf, nanf, nextafterf, nexttowardf)
421 426 #pragma does_not_read_global_data(fdimf, fmaxf, fminf, fmaf)
422 427 #pragma does_not_write_global_data(acosf, asinf, atanf, atan2f)
423 428 #pragma does_not_write_global_data(cosf, sinf, tanf)
424 429 #pragma does_not_write_global_data(acoshf, asinhf, atanhf, coshf, sinhf, tanhf)
425 430 #pragma does_not_write_global_data(expf, exp2f, expm1f, ilogbf, ldexpf)
426 431 #pragma does_not_write_global_data(logf, log10f, log1pf, log2f, logbf)
427 432 #pragma does_not_write_global_data(cbrtf, fabsf, hypotf, powf, sqrtf)
428 433 #pragma does_not_write_global_data(erff, erfcf, tgammaf)
429 434 #pragma does_not_write_global_data(ceilf, floorf, nearbyintf)
430 435 #pragma does_not_write_global_data(rintf, lrintf, roundf, lroundf, truncf)
431 436 #pragma does_not_write_global_data(fmodf, remainderf)
432 437 #pragma does_not_write_global_data(copysignf, nanf, nextafterf, nexttowardf)
433 438 #pragma does_not_write_global_data(fdimf, fmaxf, fminf, fmaf)
434 439
435 440 #pragma does_not_read_global_data(acosl, asinl, atanl, atan2l)
436 441 #pragma does_not_read_global_data(cosl, sinl, tanl)
437 442 #pragma does_not_read_global_data(acoshl, asinhl, atanhl, coshl, sinhl, tanhl)
438 443 #pragma does_not_read_global_data(expl, exp2l, expm1l, frexpl, ilogbl, ldexpl)
439 444 #pragma does_not_read_global_data(logl, log10l, log1pl, log2l, logbl)
440 445 #pragma does_not_read_global_data(modfl, scalbnl, scalblnl)
441 446 #pragma does_not_read_global_data(cbrtl, fabsl, hypotl, powl, sqrtl)
442 447 #pragma does_not_read_global_data(erfl, erfcl, lgammal, tgammal)
443 448 #pragma does_not_read_global_data(ceill, floorl, nearbyintl)
444 449 #pragma does_not_read_global_data(rintl, lrintl, roundl, lroundl, truncl)
445 450 #pragma does_not_read_global_data(fmodl, remainderl, remquol)
446 451 #pragma does_not_read_global_data(copysignl, nanl, nextafterl, nexttowardl)
447 452 #pragma does_not_read_global_data(fdiml, fmaxl, fminl, fmal)
448 453 #pragma does_not_write_global_data(acosl, asinl, atanl, atan2l)
449 454 #pragma does_not_write_global_data(cosl, sinl, tanl)
450 455 #pragma does_not_write_global_data(acoshl, asinhl, atanhl, coshl, sinhl, tanhl)
451 456 #pragma does_not_write_global_data(expl, exp2l, expm1l, ilogbl, ldexpl)
452 457 #pragma does_not_write_global_data(logl, log10l, log1pl, log2l, logbl)
453 458 #pragma does_not_write_global_data(cbrtl, fabsl, hypotl, powl, sqrtl)
454 459 #pragma does_not_write_global_data(erfl, erfcl, tgammal)
455 460 #pragma does_not_write_global_data(ceill, floorl, nearbyintl)
456 461 #pragma does_not_write_global_data(rintl, lrintl, roundl, lroundl, truncl)
457 462 #pragma does_not_write_global_data(fmodl, remainderl)
458 463 #pragma does_not_write_global_data(copysignl, nanl, nextafterl, nexttowardl)
459 464 #pragma does_not_write_global_data(fdiml, fmaxl, fminl, fmal)
460 465
461 466 #if !defined(_STRICT_STDC) && !defined(_NO_LONGLONG) || defined(_STDC_C99) || \
462 467 defined(__C99FEATURES__)
463 468 #pragma does_not_read_global_data(llrint, llround)
464 469 #pragma does_not_read_global_data(llrintf, llroundf, llrintl, llroundl)
465 470 #pragma does_not_write_global_data(llrint, llround)
466 471 #pragma does_not_write_global_data(llrintf, llroundf, llrintl, llroundl)
467 472 #endif
468 473 #endif /* !defined(__cplusplus) */
469 474
470 475 #if defined(__MATHERR_ERRNO_DONTCARE)
471 476 #pragma does_not_read_global_data(acosh, atanh, hypot, lgamma, log1p, logb)
472 477 #pragma does_not_read_global_data(nextafter, remainder)
473 478 #pragma does_not_write_global_data(acosh, atanh, hypot, log1p, logb)
474 479 #pragma does_not_write_global_data(nextafter, remainder)
475 480
476 481 #pragma no_side_effect(acosh, asinh, atanh, exp2, expm1)
477 482 #pragma no_side_effect(ilogb, log1p, log2, logb)
478 483 #pragma no_side_effect(scalbn, scalbln, cbrt, hypot)
479 484 #pragma no_side_effect(erf, erfc, tgamma)
480 485 #pragma no_side_effect(nearbyint, rint, lrint, round, lround, trunc)
481 486 #pragma no_side_effect(remainder)
482 487 #pragma no_side_effect(copysign, nan, nextafter, nexttoward)
483 488 #pragma no_side_effect(fdim, fmax, fmin, fma)
484 489
485 490 #pragma no_side_effect(acosf, asinf, atanf, atan2f)
486 491 #pragma no_side_effect(cosf, sinf, tanf, coshf, sinhf, tanhf)
487 492 #pragma no_side_effect(acoshf, asinhf, atanhf, coshf, sinhf, tanhf)
488 493 #pragma no_side_effect(expf, exp2f, expm1f, ilogbf, ldexpf)
489 494 #pragma no_side_effect(logf, log10f, log1pf, log2f, logbf)
490 495 #pragma no_side_effect(cbrtf, fabsf, hypotf, powf, sqrtf)
491 496 #pragma no_side_effect(erff, erfcf, tgammaf)
492 497 #pragma no_side_effect(ceilf, floorf, nearbyintf)
493 498 #pragma no_side_effect(rintf, lrintf, roundf, lroundf, truncf)
494 499 #pragma no_side_effect(fmodf, remainderf)
495 500 #pragma no_side_effect(copysignf, nanf, nextafterf, nexttowardf)
496 501 #pragma no_side_effect(fdimf, fmaxf, fminf, fmaf)
497 502
498 503 #pragma no_side_effect(acosl, asinl, atanl, atan2l)
499 504 #pragma no_side_effect(cosl, sinl, tanl, coshl, sinhl, tanhl)
500 505 #pragma no_side_effect(acoshl, asinhl, atanhl, coshl, sinhl, tanhl)
501 506 #pragma no_side_effect(expl, exp2l, expm1l, ilogbl, ldexpl)
502 507 #pragma no_side_effect(logl, log10l, log1pl, log2l, logbl)
503 508 #pragma no_side_effect(cbrtl, fabsl, hypotl, powl, sqrtl)
504 509 #pragma no_side_effect(erfl, erfcl, tgammal)
505 510 #pragma no_side_effect(ceill, floorl, nearbyintl)
506 511 #pragma no_side_effect(rintl, lrintl, roundl, lroundl, truncl)
507 512 #pragma no_side_effect(fmodl, remainderl)
508 513 #pragma no_side_effect(copysignl, nanl, nextafterl, nexttowardl)
509 514 #pragma no_side_effect(fdiml, fmaxl, fminl, fmal)
510 515
511 516 #if !defined(_STRICT_STDC) && !defined(_NO_LONGLONG) || defined(_STDC_C99) || \
512 517 defined(__C99FEATURES__)
513 518 #pragma no_side_effect(llrint, llround, llrintf, llroundf, llrintl, llroundl)
514 519 #endif
515 520 #endif /* defined(__MATHERR_ERRNO_DONTCARE) */
516 521 #endif /* defined(__EXTENSIONS__) || defined(_STDC_C99) || ... */
517 522
518 523 #ifdef __cplusplus
519 524 }
520 525 #endif
521 526
522 527 #endif /* _ISO_MATH_C99_H */
|
↓ open down ↓ |
318 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX