(__TGMATH_BINARY_FIRST_REAL_ONLY, __TGMATH_BINARY_REAL_ONLY,
authordrepper <drepper>
Thu, 25 Jan 2001 19:54:03 +0000 (19:54 +0000)
committerdrepper <drepper>
Thu, 25 Jan 2001 19:54:03 +0000 (19:54 +0000)
__TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY, __TGMATH_TERNARY_REAL_ONLY):
Use proper arguments to __builtin_classify_type, add ##f suffixes where
appropriate.
(__TGMATH_UNARY_REAL_IMAG): Remove extraneous left parenthesis.
(__TGMATH_BINARY_REAL_IMAG): Likewise, use proper arguments to
__builtin_classify_type.
(fma): Fix spelling of first argument.

math/tgmath.h

index 50d4d42..1f19b14 100644 (file)
@@ -71,7 +71,7 @@
 # define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \
      (__extension__ ({ __tgmath_real_type (Val1) __tgmres;                   \
                       if (sizeof (Val1) == sizeof (double)                   \
-                          || __builtin_classify_type (Val) != 8)             \
+                          || __builtin_classify_type (Val1) != 8)            \
                         __tgmres = Fct (Val1, Val2);                         \
                       else if (sizeof (Val1) == sizeof (float))              \
                         __tgmres = Fct##f (Val1, Val2);                      \
      (__extension__ ({ __tgmath_real_type ((Val1) + (Val2)) __tgmres;        \
                       if ((sizeof (Val1) > sizeof (double)                   \
                            || sizeof (Val2) > sizeof (double))               \
-                          && __builtin_classify_type (Val) == 8)             \
+                          && __builtin_classify_type ((Val1) + (Val2)) == 8) \
                         __tgmres = Fct##l (Val1, Val2);                      \
                       else if (sizeof (Val1) == sizeof (double)              \
                                || sizeof (Val2) == sizeof (double)           \
-                               || __builtin_classify_type (Val) != 8)        \
+                               || __builtin_classify_type ((Val1)            \
+                                                           + (Val2)) != 8)   \
                         __tgmres = Fct (Val1, Val2);                         \
                       else                                                   \
-                        __tgmres = Fct (Val1, Val2);                         \
+                        __tgmres = Fct##f (Val1, Val2);                      \
                       __tgmres; }))
 
 # define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \
      (__extension__ ({ __tgmath_real_type ((Val1) + (Val2)) __tgmres;        \
                       if ((sizeof (Val1) > sizeof (double)                   \
                            || sizeof (Val2) > sizeof (double))               \
-                          && __builtin_classify_type (Val) == 8)             \
+                          && __builtin_classify_type ((Val1) + (Val2)) == 8) \
                         __tgmres = Fct##l (Val1, Val2, Val3);                \
                       else if (sizeof (Val1) == sizeof (double)              \
                                || sizeof (Val2) == sizeof (double)           \
-                               || __builtin_classify_type (Val) != 8)        \
+                               || __builtin_classify_type ((Val1)            \
+                                                           + (Val2)) != 8)   \
                         __tgmres = Fct (Val1, Val2, Val3);                   \
                       else                                                   \
-                        __tgmres = Fct (Val1, Val2, Val3);                   \
+                        __tgmres = Fct##f (Val1, Val2, Val3);                \
                       __tgmres; }))
 
 # define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \
                       if ((sizeof (Val1) > sizeof (double)                   \
                            || sizeof (Val2) > sizeof (double)                \
                            || sizeof (Val3) > sizeof (double))               \
-                          && __builtin_classify_type (Val) == 8)             \
+                          && __builtin_classify_type ((Val1) + (Val2)        \
+                                                      + (Val3)) == 8)        \
                         __tgmres = Fct##l (Val1, Val2, Val3);                \
                       else if (sizeof (Val1) == sizeof (double)              \
                                || sizeof (Val2) == sizeof (double)           \
                                || sizeof (Val3) == sizeof (double)           \
-                               || __builtin_classify_type (Val) != 8)        \
+                               || __builtin_classify_type ((Val1) + (Val2)   \
+                                                           + (Val3)) != 8)   \
                         __tgmres = Fct (Val1, Val2, Val3);                   \
                       else                                                   \
-                        __tgmres = Fct (Val1, Val2, Val3);                   \
+                        __tgmres = Fct##f (Val1, Val2, Val3);                \
                       __tgmres; }))
 
 /* XXX This definition has to be changed as soon as the compiler understands
                             __tgmres = Cfct##l (Val);                        \
                         }                                                    \
                       else if (sizeof (__real__ (Val)) == sizeof (double)    \
-                               || (__builtin_classify_type (__real__ (Val))  \
-                                   != 8)                                     \
+                               || __builtin_classify_type (__real__ (Val))   \
+                                  != 8)                                      \
                         {                                                    \
                           if (sizeof (__real__ (Val)) == sizeof (Val))       \
                             __tgmres = Fct (Val);                            \
      (__extension__ ({ __tgmath_real_type ((Val1) + (Val2)) __tgmres;        \
                       if ((sizeof (__real__ (Val1)) > sizeof (double)        \
                            || sizeof (__real__ (Val2)) > sizeof (double))    \
-                          && __builtin_classify_type (__real__ (Val)) == 8)  \
+                          && __builtin_classify_type (__real__ (Val1)        \
+                                                      + __real__ (Val2))     \
+                             == 8)                                           \
                         {                                                    \
                           if (sizeof (__real__ (Val1)) == sizeof (Val1)      \
                               && sizeof (__real__ (Val2)) == sizeof (Val2))  \
                         }                                                    \
                       else if (sizeof (__real__ (Val1)) == sizeof (double)   \
                                || sizeof (__real__ (Val2)) == sizeof(double) \
-                               || (__builtin_classify_type (__real__ (Val))  \
-                                   != 8)                                     \
+                               || __builtin_classify_type (__real__ (Val1)   \
+                                                           + __real__ (Val2))\
+                                  != 8)                                      \
                         {                                                    \
                           if (sizeof (__real__ (Val1)) == sizeof (Val1)      \
                               && sizeof (__real__ (Val2)) == sizeof (Val2))  \
 
 
 /* Multiply-add function computed as a ternary operation.  */
-#define fma(Vat1, Val2, Val3) \
+#define fma(Val1, Val2, Val3) \
      __TGMATH_TERNARY_REAL_ONLY (Val1, Val2, Val3, fma)