diff options
Diffstat (limited to 'lib/gcc/arm-eabi/4.6.x-google/include/tgmath.h')
| -rw-r--r-- | lib/gcc/arm-eabi/4.6.x-google/include/tgmath.h | 171 |
1 files changed, 171 insertions, 0 deletions
diff --git a/lib/gcc/arm-eabi/4.6.x-google/include/tgmath.h b/lib/gcc/arm-eabi/4.6.x-google/include/tgmath.h new file mode 100644 index 0000000..1fe4988 --- /dev/null +++ b/lib/gcc/arm-eabi/4.6.x-google/include/tgmath.h @@ -0,0 +1,171 @@ +/* Copyright (C) 2004, 2005, 2009 Free Software Foundation, Inc. + Contributed by Apple, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +Under Section 7 of GPL version 3, you are granted additional +permissions described in the GCC Runtime Library Exception, version +3.1, as published by the Free Software Foundation. + +You should have received a copy of the GNU General Public License and +a copy of the GCC Runtime Library Exception along with this program; +see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +<http://www.gnu.org/licenses/>. */ + +/* + * ISO C Standard: 7.22 Type-generic math <tgmath.h> + */ + +#ifndef _TGMATH_H +#define _TGMATH_H + +#include <math.h> + +#ifndef __cplusplus +#include <complex.h> + +/* Naming convention: generic macros are defining using + __TGMATH_CPLX*, __TGMATH_REAL*, and __TGMATH_CPLX_ONLY. _CPLX + means the generic argument(s) may be real or complex, _REAL means + real only, _CPLX means complex only. If there is no suffix, we are + defining a function of one generic argument. If the suffix is _n + it is a function of n generic arguments. If the suffix is _m_n it + is a function of n arguments, the first m of which are generic. We + only define these macros for values of n and/or m that are needed. */ + +/* The general rules for generic macros are given in 7.22 paragraphs 1 and 2. + If any generic parameter is complex, we use a complex version. Otherwise + we use a real version. If the real part of any generic parameter is long + double, we use the long double version. Otherwise if the real part of any + generic parameter is double or of integer type, we use the double version. + Otherwise we use the float version. */ + +#define __tg_cplx(expr) \ + __builtin_classify_type(expr) == 9 + +#define __tg_ldbl(expr) \ + __builtin_types_compatible_p(__typeof__(expr), long double) + +#define __tg_dbl(expr) \ + (__builtin_types_compatible_p(__typeof__(expr), double) \ + || __builtin_classify_type(expr) == 1) + +#define __tg_choose(x,f,d,l) \ + __builtin_choose_expr(__tg_ldbl(x), l, \ + __builtin_choose_expr(__tg_dbl(x), d, \ + f)) + +#define __tg_choose_2(x,y,f,d,l) \ + __builtin_choose_expr(__tg_ldbl(x) || __tg_ldbl(y), l, \ + __builtin_choose_expr(__tg_dbl(x) || __tg_dbl(y), d, \ + f)) + +#define __tg_choose_3(x,y,z,f,d,l) \ + __builtin_choose_expr(__tg_ldbl(x) || __tg_ldbl(y) || __tg_ldbl(z), l, \ + __builtin_choose_expr(__tg_dbl(x) || __tg_dbl(y) \ + || __tg_dbl(z), d, \ + f)) + +#define __TGMATH_CPLX(z,R,C) \ + __builtin_choose_expr (__tg_cplx(z), \ + __tg_choose (__real__(z), C##f(z), (C)(z), C##l(z)), \ + __tg_choose (z, R##f(z), (R)(z), R##l(z))) + +#define __TGMATH_CPLX_2(z1,z2,R,C) \ + __builtin_choose_expr (__tg_cplx(z1) || __tg_cplx(z2), \ + __tg_choose_2 (__real__(z1), __real__(z2), \ + C##f(z1,z2), (C)(z1,z2), C##l(z1,z2)), \ + __tg_choose_2 (z1, z2, \ + R##f(z1,z2), (R)(z1,z2), R##l(z1,z2))) + +#define __TGMATH_REAL(x,R) \ + __tg_choose (x, R##f(x), (R)(x), R##l(x)) +#define __TGMATH_REAL_2(x,y,R) \ + __tg_choose_2 (x, y, R##f(x,y), (R)(x,y), R##l(x,y)) +#define __TGMATH_REAL_3(x,y,z,R) \ + __tg_choose_3 (x, y, z, R##f(x,y,z), (R)(x,y,z), R##l(x,y,z)) +#define __TGMATH_REAL_1_2(x,y,R) \ + __tg_choose (x, R##f(x,y), (R)(x,y), R##l(x,y)) +#define __TGMATH_REAL_2_3(x,y,z,R) \ + __tg_choose_2 (x, y, R##f(x,y,z), (R)(x,y,z), R##l(x,y,z)) +#define __TGMATH_CPLX_ONLY(z,C) \ + __tg_choose (__real__(z), C##f(z), (C)(z), C##l(z)) + +/* Functions defined in both <math.h> and <complex.h> (7.22p4) */ +#define acos(z) __TGMATH_CPLX(z, acos, cacos) +#define asin(z) __TGMATH_CPLX(z, asin, casin) +#define atan(z) __TGMATH_CPLX(z, atan, catan) +#define acosh(z) __TGMATH_CPLX(z, acosh, cacosh) +#define asinh(z) __TGMATH_CPLX(z, asinh, casinh) +#define atanh(z) __TGMATH_CPLX(z, atanh, catanh) +#define cos(z) __TGMATH_CPLX(z, cos, ccos) +#define sin(z) __TGMATH_CPLX(z, sin, csin) +#define tan(z) __TGMATH_CPLX(z, tan, ctan) +#define cosh(z) __TGMATH_CPLX(z, cosh, ccosh) +#define sinh(z) __TGMATH_CPLX(z, sinh, csinh) +#define tanh(z) __TGMATH_CPLX(z, tanh, ctanh) +#define exp(z) __TGMATH_CPLX(z, exp, cexp) +#define log(z) __TGMATH_CPLX(z, log, clog) +#define pow(z1,z2) __TGMATH_CPLX_2(z1, z2, pow, cpow) +#define sqrt(z) __TGMATH_CPLX(z, sqrt, csqrt) +#define fabs(z) __TGMATH_CPLX(z, fabs, cabs) + +/* Functions defined in <math.h> only (7.22p5) */ +#define atan2(x,y) __TGMATH_REAL_2(x, y, atan2) +#define cbrt(x) __TGMATH_REAL(x, cbrt) +#define ceil(x) __TGMATH_REAL(x, ceil) +#define copysign(x,y) __TGMATH_REAL_2(x, y, copysign) +#define erf(x) __TGMATH_REAL(x, erf) +#define erfc(x) __TGMATH_REAL(x, erfc) +#define exp2(x) __TGMATH_REAL(x, exp2) +#define expm1(x) __TGMATH_REAL(x, expm1) +#define fdim(x,y) __TGMATH_REAL_2(x, y, fdim) +#define floor(x) __TGMATH_REAL(x, floor) +#define fma(x,y,z) __TGMATH_REAL_3(x, y, z, fma) +#define fmax(x,y) __TGMATH_REAL_2(x, y, fmax) +#define fmin(x,y) __TGMATH_REAL_2(x, y, fmin) +#define fmod(x,y) __TGMATH_REAL_2(x, y, fmod) +#define frexp(x,y) __TGMATH_REAL_1_2(x, y, frexp) +#define hypot(x,y) __TGMATH_REAL_2(x, y, hypot) +#define ilogb(x) __TGMATH_REAL(x, ilogb) +#define ldexp(x,y) __TGMATH_REAL_1_2(x, y, ldexp) +#define lgamma(x) __TGMATH_REAL(x, lgamma) +#define llrint(x) __TGMATH_REAL(x, llrint) +#define llround(x) __TGMATH_REAL(x, llround) +#define log10(x) __TGMATH_REAL(x, log10) +#define log1p(x) __TGMATH_REAL(x, log1p) +#define log2(x) __TGMATH_REAL(x, log2) +#define logb(x) __TGMATH_REAL(x, logb) +#define lrint(x) __TGMATH_REAL(x, lrint) +#define lround(x) __TGMATH_REAL(x, lround) +#define nearbyint(x) __TGMATH_REAL(x, nearbyint) +#define nextafter(x,y) __TGMATH_REAL_2(x, y, nextafter) +#define nexttoward(x,y) __TGMATH_REAL_1_2(x, y, nexttoward) +#define remainder(x,y) __TGMATH_REAL_2(x, y, remainder) +#define remquo(x,y,z) __TGMATH_REAL_2_3(x, y, z, remquo) +#define rint(x) __TGMATH_REAL(x, rint) +#define round(x) __TGMATH_REAL(x, round) +#define scalbn(x,y) __TGMATH_REAL_1_2(x, y, scalbn) +#define scalbln(x,y) __TGMATH_REAL_1_2(x, y, scalbln) +#define tgamma(x) __TGMATH_REAL(x, tgamma) +#define trunc(x) __TGMATH_REAL(x, trunc) + +/* Functions defined in <complex.h> only (7.22p6) */ +#define carg(z) __TGMATH_CPLX_ONLY(z, carg) +#define cimag(z) __TGMATH_CPLX_ONLY(z, cimag) +#define conj(z) __TGMATH_CPLX_ONLY(z, conj) +#define cproj(z) __TGMATH_CPLX_ONLY(z, cproj) +#define creal(z) __TGMATH_CPLX_ONLY(z, creal) + +#endif /* __cplusplus */ +#endif /* _TGMATH_H */ |