Index: third_party/asan/asan_clang_Linux/lib/clang/3.1/include/tgmath.h |
=================================================================== |
--- third_party/asan/asan_clang_Linux/lib/clang/3.1/include/tgmath.h (revision 0) |
+++ third_party/asan/asan_clang_Linux/lib/clang/3.1/include/tgmath.h (revision 0) |
@@ -0,0 +1,1357 @@ |
+/*===---- tgmath.h - Standard header for type generic math ----------------===*\ |
+ * |
+ * Copyright (c) 2009 Howard Hinnant |
+ * |
+ * Permission is hereby granted, free of charge, to any person obtaining a copy |
+ * of this software and associated documentation files (the "Software"), to deal |
+ * in the Software without restriction, including without limitation the rights |
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
+ * copies of the Software, and to permit persons to whom the Software is |
+ * furnished to do so, subject to the following conditions: |
+ * |
+ * The above copyright notice and this permission notice shall be included in |
+ * all copies or substantial portions of the Software. |
+ * |
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
+ * THE SOFTWARE. |
+ * |
+\*===----------------------------------------------------------------------===*/ |
+ |
+#ifndef __TGMATH_H |
+#define __TGMATH_H |
+ |
+/* C99 7.22 Type-generic math <tgmath.h>. */ |
+#include <math.h> |
+ |
+/* C++ handles type genericity with overloading in math.h. */ |
+#ifndef __cplusplus |
+#include <complex.h> |
+ |
+#define _TG_ATTRSp __attribute__((__overloadable__)) |
+#define _TG_ATTRS __attribute__((__overloadable__, __always_inline__)) |
+ |
+// promotion |
+ |
+typedef void _Argument_type_is_not_arithmetic; |
+static _Argument_type_is_not_arithmetic __tg_promote(...) |
+ __attribute__((__unavailable__,__overloadable__)); |
+static double _TG_ATTRSp __tg_promote(int); |
+static double _TG_ATTRSp __tg_promote(unsigned int); |
+static double _TG_ATTRSp __tg_promote(long); |
+static double _TG_ATTRSp __tg_promote(unsigned long); |
+static double _TG_ATTRSp __tg_promote(long long); |
+static double _TG_ATTRSp __tg_promote(unsigned long long); |
+static float _TG_ATTRSp __tg_promote(float); |
+static double _TG_ATTRSp __tg_promote(double); |
+static long double _TG_ATTRSp __tg_promote(long double); |
+static float _Complex _TG_ATTRSp __tg_promote(float _Complex); |
+static double _Complex _TG_ATTRSp __tg_promote(double _Complex); |
+static long double _Complex _TG_ATTRSp __tg_promote(long double _Complex); |
+ |
+#define __tg_promote1(__x) (__typeof__(__tg_promote(__x))) |
+#define __tg_promote2(__x, __y) (__typeof__(__tg_promote(__x) + \ |
+ __tg_promote(__y))) |
+#define __tg_promote3(__x, __y, __z) (__typeof__(__tg_promote(__x) + \ |
+ __tg_promote(__y) + \ |
+ __tg_promote(__z))) |
+ |
+// acos |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_acos(float __x) {return acosf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_acos(double __x) {return acos(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_acos(long double __x) {return acosl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_acos(float _Complex __x) {return cacosf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_acos(double _Complex __x) {return cacos(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_acos(long double _Complex __x) {return cacosl(__x);} |
+ |
+#undef acos |
+#define acos(__x) __tg_acos(__tg_promote1((__x))(__x)) |
+ |
+// asin |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_asin(float __x) {return asinf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_asin(double __x) {return asin(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_asin(long double __x) {return asinl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_asin(float _Complex __x) {return casinf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_asin(double _Complex __x) {return casin(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_asin(long double _Complex __x) {return casinl(__x);} |
+ |
+#undef asin |
+#define asin(__x) __tg_asin(__tg_promote1((__x))(__x)) |
+ |
+// atan |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_atan(float __x) {return atanf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_atan(double __x) {return atan(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_atan(long double __x) {return atanl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_atan(float _Complex __x) {return catanf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_atan(double _Complex __x) {return catan(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_atan(long double _Complex __x) {return catanl(__x);} |
+ |
+#undef atan |
+#define atan(__x) __tg_atan(__tg_promote1((__x))(__x)) |
+ |
+// acosh |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_acosh(float __x) {return acoshf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_acosh(double __x) {return acosh(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_acosh(long double __x) {return acoshl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_acosh(float _Complex __x) {return cacoshf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_acosh(double _Complex __x) {return cacosh(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_acosh(long double _Complex __x) {return cacoshl(__x);} |
+ |
+#undef acosh |
+#define acosh(__x) __tg_acosh(__tg_promote1((__x))(__x)) |
+ |
+// asinh |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_asinh(float __x) {return asinhf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_asinh(double __x) {return asinh(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_asinh(long double __x) {return asinhl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_asinh(float _Complex __x) {return casinhf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_asinh(double _Complex __x) {return casinh(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_asinh(long double _Complex __x) {return casinhl(__x);} |
+ |
+#undef asinh |
+#define asinh(__x) __tg_asinh(__tg_promote1((__x))(__x)) |
+ |
+// atanh |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_atanh(float __x) {return atanhf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_atanh(double __x) {return atanh(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_atanh(long double __x) {return atanhl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_atanh(float _Complex __x) {return catanhf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_atanh(double _Complex __x) {return catanh(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_atanh(long double _Complex __x) {return catanhl(__x);} |
+ |
+#undef atanh |
+#define atanh(__x) __tg_atanh(__tg_promote1((__x))(__x)) |
+ |
+// cos |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_cos(float __x) {return cosf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_cos(double __x) {return cos(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_cos(long double __x) {return cosl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_cos(float _Complex __x) {return ccosf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_cos(double _Complex __x) {return ccos(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_cos(long double _Complex __x) {return ccosl(__x);} |
+ |
+#undef cos |
+#define cos(__x) __tg_cos(__tg_promote1((__x))(__x)) |
+ |
+// sin |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_sin(float __x) {return sinf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_sin(double __x) {return sin(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_sin(long double __x) {return sinl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_sin(float _Complex __x) {return csinf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_sin(double _Complex __x) {return csin(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_sin(long double _Complex __x) {return csinl(__x);} |
+ |
+#undef sin |
+#define sin(__x) __tg_sin(__tg_promote1((__x))(__x)) |
+ |
+// tan |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_tan(float __x) {return tanf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_tan(double __x) {return tan(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_tan(long double __x) {return tanl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_tan(float _Complex __x) {return ctanf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_tan(double _Complex __x) {return ctan(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_tan(long double _Complex __x) {return ctanl(__x);} |
+ |
+#undef tan |
+#define tan(__x) __tg_tan(__tg_promote1((__x))(__x)) |
+ |
+// cosh |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_cosh(float __x) {return coshf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_cosh(double __x) {return cosh(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_cosh(long double __x) {return coshl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_cosh(float _Complex __x) {return ccoshf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_cosh(double _Complex __x) {return ccosh(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_cosh(long double _Complex __x) {return ccoshl(__x);} |
+ |
+#undef cosh |
+#define cosh(__x) __tg_cosh(__tg_promote1((__x))(__x)) |
+ |
+// sinh |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_sinh(float __x) {return sinhf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_sinh(double __x) {return sinh(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_sinh(long double __x) {return sinhl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_sinh(float _Complex __x) {return csinhf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_sinh(double _Complex __x) {return csinh(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_sinh(long double _Complex __x) {return csinhl(__x);} |
+ |
+#undef sinh |
+#define sinh(__x) __tg_sinh(__tg_promote1((__x))(__x)) |
+ |
+// tanh |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_tanh(float __x) {return tanhf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_tanh(double __x) {return tanh(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_tanh(long double __x) {return tanhl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_tanh(float _Complex __x) {return ctanhf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_tanh(double _Complex __x) {return ctanh(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_tanh(long double _Complex __x) {return ctanhl(__x);} |
+ |
+#undef tanh |
+#define tanh(__x) __tg_tanh(__tg_promote1((__x))(__x)) |
+ |
+// exp |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_exp(float __x) {return expf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_exp(double __x) {return exp(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_exp(long double __x) {return expl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_exp(float _Complex __x) {return cexpf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_exp(double _Complex __x) {return cexp(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_exp(long double _Complex __x) {return cexpl(__x);} |
+ |
+#undef exp |
+#define exp(__x) __tg_exp(__tg_promote1((__x))(__x)) |
+ |
+// log |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_log(float __x) {return logf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_log(double __x) {return log(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_log(long double __x) {return logl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_log(float _Complex __x) {return clogf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_log(double _Complex __x) {return clog(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_log(long double _Complex __x) {return clogl(__x);} |
+ |
+#undef log |
+#define log(__x) __tg_log(__tg_promote1((__x))(__x)) |
+ |
+// pow |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_pow(float __x, float __y) {return powf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_pow(double __x, double __y) {return pow(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_pow(long double __x, long double __y) {return powl(__x, __y);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_pow(float _Complex __x, float _Complex __y) {return cpowf(__x, __y);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_pow(double _Complex __x, double _Complex __y) {return cpow(__x, __y);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_pow(long double _Complex __x, long double _Complex __y) |
+ {return cpowl(__x, __y);} |
+ |
+#undef pow |
+#define pow(__x, __y) __tg_pow(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// sqrt |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_sqrt(float __x) {return sqrtf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_sqrt(double __x) {return sqrt(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_sqrt(long double __x) {return sqrtl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_sqrt(float _Complex __x) {return csqrtf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_sqrt(double _Complex __x) {return csqrt(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_sqrt(long double _Complex __x) {return csqrtl(__x);} |
+ |
+#undef sqrt |
+#define sqrt(__x) __tg_sqrt(__tg_promote1((__x))(__x)) |
+ |
+// fabs |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_fabs(float __x) {return fabsf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_fabs(double __x) {return fabs(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_fabs(long double __x) {return fabsl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_fabs(float _Complex __x) {return cabsf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_fabs(double _Complex __x) {return cabs(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_fabs(long double _Complex __x) {return cabsl(__x);} |
+ |
+#undef fabs |
+#define fabs(__x) __tg_fabs(__tg_promote1((__x))(__x)) |
+ |
+// atan2 |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_atan2(float __x, float __y) {return atan2f(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_atan2(double __x, double __y) {return atan2(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_atan2(long double __x, long double __y) {return atan2l(__x, __y);} |
+ |
+#undef atan2 |
+#define atan2(__x, __y) __tg_atan2(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// cbrt |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_cbrt(float __x) {return cbrtf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_cbrt(double __x) {return cbrt(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_cbrt(long double __x) {return cbrtl(__x);} |
+ |
+#undef cbrt |
+#define cbrt(__x) __tg_cbrt(__tg_promote1((__x))(__x)) |
+ |
+// ceil |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_ceil(float __x) {return ceilf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_ceil(double __x) {return ceil(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_ceil(long double __x) {return ceill(__x);} |
+ |
+#undef ceil |
+#define ceil(__x) __tg_ceil(__tg_promote1((__x))(__x)) |
+ |
+// copysign |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_copysign(float __x, float __y) {return copysignf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_copysign(double __x, double __y) {return copysign(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_copysign(long double __x, long double __y) {return copysignl(__x, __y);} |
+ |
+#undef copysign |
+#define copysign(__x, __y) __tg_copysign(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// erf |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_erf(float __x) {return erff(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_erf(double __x) {return erf(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_erf(long double __x) {return erfl(__x);} |
+ |
+#undef erf |
+#define erf(__x) __tg_erf(__tg_promote1((__x))(__x)) |
+ |
+// erfc |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_erfc(float __x) {return erfcf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_erfc(double __x) {return erfc(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_erfc(long double __x) {return erfcl(__x);} |
+ |
+#undef erfc |
+#define erfc(__x) __tg_erfc(__tg_promote1((__x))(__x)) |
+ |
+// exp2 |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_exp2(float __x) {return exp2f(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_exp2(double __x) {return exp2(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_exp2(long double __x) {return exp2l(__x);} |
+ |
+#undef exp2 |
+#define exp2(__x) __tg_exp2(__tg_promote1((__x))(__x)) |
+ |
+// expm1 |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_expm1(float __x) {return expm1f(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_expm1(double __x) {return expm1(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_expm1(long double __x) {return expm1l(__x);} |
+ |
+#undef expm1 |
+#define expm1(__x) __tg_expm1(__tg_promote1((__x))(__x)) |
+ |
+// fdim |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_fdim(float __x, float __y) {return fdimf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_fdim(double __x, double __y) {return fdim(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_fdim(long double __x, long double __y) {return fdiml(__x, __y);} |
+ |
+#undef fdim |
+#define fdim(__x, __y) __tg_fdim(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// floor |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_floor(float __x) {return floorf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_floor(double __x) {return floor(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_floor(long double __x) {return floorl(__x);} |
+ |
+#undef floor |
+#define floor(__x) __tg_floor(__tg_promote1((__x))(__x)) |
+ |
+// fma |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_fma(float __x, float __y, float __z) |
+ {return fmaf(__x, __y, __z);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_fma(double __x, double __y, double __z) |
+ {return fma(__x, __y, __z);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_fma(long double __x,long double __y, long double __z) |
+ {return fmal(__x, __y, __z);} |
+ |
+#undef fma |
+#define fma(__x, __y, __z) \ |
+ __tg_fma(__tg_promote3((__x), (__y), (__z))(__x), \ |
+ __tg_promote3((__x), (__y), (__z))(__y), \ |
+ __tg_promote3((__x), (__y), (__z))(__z)) |
+ |
+// fmax |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_fmax(float __x, float __y) {return fmaxf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_fmax(double __x, double __y) {return fmax(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_fmax(long double __x, long double __y) {return fmaxl(__x, __y);} |
+ |
+#undef fmax |
+#define fmax(__x, __y) __tg_fmax(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// fmin |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_fmin(float __x, float __y) {return fminf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_fmin(double __x, double __y) {return fmin(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_fmin(long double __x, long double __y) {return fminl(__x, __y);} |
+ |
+#undef fmin |
+#define fmin(__x, __y) __tg_fmin(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// fmod |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_fmod(float __x, float __y) {return fmodf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_fmod(double __x, double __y) {return fmod(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_fmod(long double __x, long double __y) {return fmodl(__x, __y);} |
+ |
+#undef fmod |
+#define fmod(__x, __y) __tg_fmod(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// frexp |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_frexp(float __x, int* __y) {return frexpf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_frexp(double __x, int* __y) {return frexp(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_frexp(long double __x, int* __y) {return frexpl(__x, __y);} |
+ |
+#undef frexp |
+#define frexp(__x, __y) __tg_frexp(__tg_promote1((__x))(__x), __y) |
+ |
+// hypot |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_hypot(float __x, float __y) {return hypotf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_hypot(double __x, double __y) {return hypot(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_hypot(long double __x, long double __y) {return hypotl(__x, __y);} |
+ |
+#undef hypot |
+#define hypot(__x, __y) __tg_hypot(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// ilogb |
+ |
+static int |
+ _TG_ATTRS |
+ __tg_ilogb(float __x) {return ilogbf(__x);} |
+ |
+static int |
+ _TG_ATTRS |
+ __tg_ilogb(double __x) {return ilogb(__x);} |
+ |
+static int |
+ _TG_ATTRS |
+ __tg_ilogb(long double __x) {return ilogbl(__x);} |
+ |
+#undef ilogb |
+#define ilogb(__x) __tg_ilogb(__tg_promote1((__x))(__x)) |
+ |
+// ldexp |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_ldexp(float __x, int __y) {return ldexpf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_ldexp(double __x, int __y) {return ldexp(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_ldexp(long double __x, int __y) {return ldexpl(__x, __y);} |
+ |
+#undef ldexp |
+#define ldexp(__x, __y) __tg_ldexp(__tg_promote1((__x))(__x), __y) |
+ |
+// lgamma |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_lgamma(float __x) {return lgammaf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_lgamma(double __x) {return lgamma(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_lgamma(long double __x) {return lgammal(__x);} |
+ |
+#undef lgamma |
+#define lgamma(__x) __tg_lgamma(__tg_promote1((__x))(__x)) |
+ |
+// llrint |
+ |
+static long long |
+ _TG_ATTRS |
+ __tg_llrint(float __x) {return llrintf(__x);} |
+ |
+static long long |
+ _TG_ATTRS |
+ __tg_llrint(double __x) {return llrint(__x);} |
+ |
+static long long |
+ _TG_ATTRS |
+ __tg_llrint(long double __x) {return llrintl(__x);} |
+ |
+#undef llrint |
+#define llrint(__x) __tg_llrint(__tg_promote1((__x))(__x)) |
+ |
+// llround |
+ |
+static long long |
+ _TG_ATTRS |
+ __tg_llround(float __x) {return llroundf(__x);} |
+ |
+static long long |
+ _TG_ATTRS |
+ __tg_llround(double __x) {return llround(__x);} |
+ |
+static long long |
+ _TG_ATTRS |
+ __tg_llround(long double __x) {return llroundl(__x);} |
+ |
+#undef llround |
+#define llround(__x) __tg_llround(__tg_promote1((__x))(__x)) |
+ |
+// log10 |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_log10(float __x) {return log10f(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_log10(double __x) {return log10(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_log10(long double __x) {return log10l(__x);} |
+ |
+#undef log10 |
+#define log10(__x) __tg_log10(__tg_promote1((__x))(__x)) |
+ |
+// log1p |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_log1p(float __x) {return log1pf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_log1p(double __x) {return log1p(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_log1p(long double __x) {return log1pl(__x);} |
+ |
+#undef log1p |
+#define log1p(__x) __tg_log1p(__tg_promote1((__x))(__x)) |
+ |
+// log2 |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_log2(float __x) {return log2f(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_log2(double __x) {return log2(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_log2(long double __x) {return log2l(__x);} |
+ |
+#undef log2 |
+#define log2(__x) __tg_log2(__tg_promote1((__x))(__x)) |
+ |
+// lrint |
+ |
+static long |
+ _TG_ATTRS |
+ __tg_lrint(float __x) {return lrintf(__x);} |
+ |
+static long |
+ _TG_ATTRS |
+ __tg_lrint(double __x) {return lrint(__x);} |
+ |
+static long |
+ _TG_ATTRS |
+ __tg_lrint(long double __x) {return lrintl(__x);} |
+ |
+#undef lrint |
+#define lrint(__x) __tg_lrint(__tg_promote1((__x))(__x)) |
+ |
+// lround |
+ |
+static long |
+ _TG_ATTRS |
+ __tg_lround(float __x) {return lroundf(__x);} |
+ |
+static long |
+ _TG_ATTRS |
+ __tg_lround(double __x) {return lround(__x);} |
+ |
+static long |
+ _TG_ATTRS |
+ __tg_lround(long double __x) {return lroundl(__x);} |
+ |
+#undef lround |
+#define lround(__x) __tg_lround(__tg_promote1((__x))(__x)) |
+ |
+// nearbyint |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_nearbyint(float __x) {return nearbyintf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_nearbyint(double __x) {return nearbyint(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_nearbyint(long double __x) {return nearbyintl(__x);} |
+ |
+#undef nearbyint |
+#define nearbyint(__x) __tg_nearbyint(__tg_promote1((__x))(__x)) |
+ |
+// nextafter |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_nextafter(float __x, float __y) {return nextafterf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_nextafter(double __x, double __y) {return nextafter(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_nextafter(long double __x, long double __y) {return nextafterl(__x, __y);} |
+ |
+#undef nextafter |
+#define nextafter(__x, __y) __tg_nextafter(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// nexttoward |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_nexttoward(double __x, long double __y) {return nexttoward(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_nexttoward(long double __x, long double __y) {return nexttowardl(__x, __y);} |
+ |
+#undef nexttoward |
+#define nexttoward(__x, __y) __tg_nexttoward(__tg_promote1((__x))(__x), (__y)) |
+ |
+// remainder |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_remainder(float __x, float __y) {return remainderf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_remainder(double __x, double __y) {return remainder(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_remainder(long double __x, long double __y) {return remainderl(__x, __y);} |
+ |
+#undef remainder |
+#define remainder(__x, __y) __tg_remainder(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y)) |
+ |
+// remquo |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_remquo(float __x, float __y, int* __z) |
+ {return remquof(__x, __y, __z);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_remquo(double __x, double __y, int* __z) |
+ {return remquo(__x, __y, __z);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_remquo(long double __x,long double __y, int* __z) |
+ {return remquol(__x, __y, __z);} |
+ |
+#undef remquo |
+#define remquo(__x, __y, __z) \ |
+ __tg_remquo(__tg_promote2((__x), (__y))(__x), \ |
+ __tg_promote2((__x), (__y))(__y), \ |
+ (__z)) |
+ |
+// rint |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_rint(float __x) {return rintf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_rint(double __x) {return rint(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_rint(long double __x) {return rintl(__x);} |
+ |
+#undef rint |
+#define rint(__x) __tg_rint(__tg_promote1((__x))(__x)) |
+ |
+// round |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_round(float __x) {return roundf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_round(double __x) {return round(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_round(long double __x) {return roundl(__x);} |
+ |
+#undef round |
+#define round(__x) __tg_round(__tg_promote1((__x))(__x)) |
+ |
+// scalbn |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_scalbn(float __x, int __y) {return scalbnf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_scalbn(double __x, int __y) {return scalbn(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_scalbn(long double __x, int __y) {return scalbnl(__x, __y);} |
+ |
+#undef scalbn |
+#define scalbn(__x, __y) __tg_scalbn(__tg_promote1((__x))(__x), __y) |
+ |
+// scalbln |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_scalbln(float __x, long __y) {return scalblnf(__x, __y);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_scalbln(double __x, long __y) {return scalbln(__x, __y);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_scalbln(long double __x, long __y) {return scalblnl(__x, __y);} |
+ |
+#undef scalbln |
+#define scalbln(__x, __y) __tg_scalbln(__tg_promote1((__x))(__x), __y) |
+ |
+// tgamma |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_tgamma(float __x) {return tgammaf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_tgamma(double __x) {return tgamma(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_tgamma(long double __x) {return tgammal(__x);} |
+ |
+#undef tgamma |
+#define tgamma(__x) __tg_tgamma(__tg_promote1((__x))(__x)) |
+ |
+// trunc |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_trunc(float __x) {return truncf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_trunc(double __x) {return trunc(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_trunc(long double __x) {return truncl(__x);} |
+ |
+#undef trunc |
+#define trunc(__x) __tg_trunc(__tg_promote1((__x))(__x)) |
+ |
+// carg |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_carg(float __x) {return atan2f(0.F, __x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_carg(double __x) {return atan2(0., __x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_carg(long double __x) {return atan2l(0.L, __x);} |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_carg(float _Complex __x) {return cargf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_carg(double _Complex __x) {return carg(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_carg(long double _Complex __x) {return cargl(__x);} |
+ |
+#undef carg |
+#define carg(__x) __tg_carg(__tg_promote1((__x))(__x)) |
+ |
+// cimag |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_cimag(float __x) {return 0;} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_cimag(double __x) {return 0;} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_cimag(long double __x) {return 0;} |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_cimag(float _Complex __x) {return cimagf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_cimag(double _Complex __x) {return cimag(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_cimag(long double _Complex __x) {return cimagl(__x);} |
+ |
+#undef cimag |
+#define cimag(__x) __tg_cimag(__tg_promote1((__x))(__x)) |
+ |
+// conj |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_conj(float __x) {return __x;} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_conj(double __x) {return __x;} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_conj(long double __x) {return __x;} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_conj(float _Complex __x) {return conjf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_conj(double _Complex __x) {return conj(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_conj(long double _Complex __x) {return conjl(__x);} |
+ |
+#undef conj |
+#define conj(__x) __tg_conj(__tg_promote1((__x))(__x)) |
+ |
+// cproj |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_cproj(float __x) {return cprojf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_cproj(double __x) {return cproj(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_cproj(long double __x) {return cprojl(__x);} |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_cproj(float _Complex __x) {return cprojf(__x);} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_cproj(double _Complex __x) {return cproj(__x);} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_cproj(long double _Complex __x) {return cprojl(__x);} |
+ |
+#undef cproj |
+#define cproj(__x) __tg_cproj(__tg_promote1((__x))(__x)) |
+ |
+// creal |
+ |
+static float _Complex |
+ _TG_ATTRS |
+ __tg_creal(float __x) {return __x;} |
+ |
+static double _Complex |
+ _TG_ATTRS |
+ __tg_creal(double __x) {return __x;} |
+ |
+static long double _Complex |
+ _TG_ATTRS |
+ __tg_creal(long double __x) {return __x;} |
+ |
+static float |
+ _TG_ATTRS |
+ __tg_creal(float _Complex __x) {return crealf(__x);} |
+ |
+static double |
+ _TG_ATTRS |
+ __tg_creal(double _Complex __x) {return creal(__x);} |
+ |
+static long double |
+ _TG_ATTRS |
+ __tg_creal(long double _Complex __x) {return creall(__x);} |
+ |
+#undef creal |
+#define creal(__x) __tg_creal(__tg_promote1((__x))(__x)) |
+ |
+#undef _TG_ATTRSp |
+#undef _TG_ATTRS |
+ |
+#endif /* __cplusplus */ |
+#endif /* __TGMATH_H */ |
Property changes on: third_party/asan/asan_clang_Linux/lib/clang/3.1/include/tgmath.h |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |