* tree.h (BUILTIN_EXP10_P, BUILTIN_EXPONENT_P, BUILTIN_SQRT_P,

	BUILTIN_CBRT_P, BUILTIN_ROOT_P): New macros.

	* builtins.c (fold_builtin_logarithm, fold_builtin): Use new
	macros.
	* fold-const.c (fold_mathfn_compare, fold): Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@79023 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 423ff63..84824f9 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2004-03-06  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+       * tree.h (BUILTIN_EXP10_P, BUILTIN_EXPONENT_P, BUILTIN_SQRT_P,
+       BUILTIN_CBRT_P, BUILTIN_ROOT_P): New macros.
+
+       * builtins.c (fold_builtin_logarithm, fold_builtin): Use new
+       macros.
+       * fold-const.c (fold_mathfn_compare, fold): Likewise.
+
 2004-03-06  Eric Botcazou  <ebotcazou@libertysurf.fr>
 
        PR target/14343

diff --git a/gcc/builtins.c b/gcc/builtins.c
index c9aa2ab..1eeedd2 100644 (file)
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -6212,10 +6212,7 @@ fold_builtin_logarithm (tree exp, const REAL_VALUE_TYPE *value)
                  && (fcode == BUILT_IN_EXP2
                      || fcode == BUILT_IN_EXP2F
                      || fcode == BUILT_IN_EXP2L))
-             || (value == &dconst10
-                 && (fcode == BUILT_IN_EXP10
-                     || fcode == BUILT_IN_EXP10F
-                     || fcode == BUILT_IN_EXP10L))))
+             || (value == &dconst10 && (BUILTIN_EXP10_P (fcode)))))
        return convert (type, TREE_VALUE (TREE_OPERAND (arg, 1)));
 
       /* Optimize logN(func()) for various exponential functions.  We
@@ -6725,12 +6722,9 @@ fold_builtin (tree exp)
                return build_real (type, r);
            }
 
-         /* Optimize sqrt(exp(x)) = exp(x*0.5).  */
+         /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
          fcode = builtin_mathfn_code (arg);
-         if (flag_unsafe_math_optimizations
-             && (fcode == BUILT_IN_EXP
-                 || fcode == BUILT_IN_EXPF
-                 || fcode == BUILT_IN_EXPL))
+         if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
            {
              tree expfn = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
              arg = fold (build (MULT_EXPR, type,
@@ -6948,12 +6942,9 @@ fold_builtin (tree exp)
                }
            }
 
-         /* Optimize pow(exp(x),y) = exp(x*y).  */
+         /* Optimize pow(expN(x),y) = expN(x*y).  */
          fcode = builtin_mathfn_code (arg0);
-         if (flag_unsafe_math_optimizations
-             && (fcode == BUILT_IN_EXP
-                 || fcode == BUILT_IN_EXPF
-                 || fcode == BUILT_IN_EXPL))
+         if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
            {
              tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
              tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
@@ -6963,10 +6954,7 @@ fold_builtin (tree exp)
            }
 
          /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
-         if (flag_unsafe_math_optimizations
-             && (fcode == BUILT_IN_SQRT
-                 || fcode == BUILT_IN_SQRTF
-                 || fcode == BUILT_IN_SQRTL))
+         if (flag_unsafe_math_optimizations && BUILTIN_SQRT_P (fcode))
            {
              tree narg0 = TREE_VALUE (TREE_OPERAND (arg0, 1));
              tree narg1 = fold (build (MULT_EXPR, type, arg1,

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index cffa2ec..9bf3b7a 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -4985,9 +4985,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
 {
   REAL_VALUE_TYPE c;
 
-  if (fcode == BUILT_IN_SQRT
-      || fcode == BUILT_IN_SQRTF
-      || fcode == BUILT_IN_SQRTL)
+  if (BUILTIN_SQRT_P (fcode))
     {
       tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
@@ -6425,9 +6423,7 @@ fold (tree expr)
              enum built_in_function fcode1 = builtin_mathfn_code (arg1);
 
              /* Optimizations of sqrt(...)*sqrt(...).  */
-             if ((fcode0 == BUILT_IN_SQRT && fcode1 == BUILT_IN_SQRT)
-                 || (fcode0 == BUILT_IN_SQRTF && fcode1 == BUILT_IN_SQRTF)
-                 || (fcode0 == BUILT_IN_SQRTL && fcode1 == BUILT_IN_SQRTL))
+             if (fcode0 == fcode1 && BUILTIN_SQRT_P (fcode0))
                {
                  tree sqrtfn, arg, arglist;
                  tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
@@ -6446,19 +6442,7 @@ fold (tree expr)
                }
 
              /* Optimize expN(x)*expN(y) as expN(x+y).  */
-             if (fcode0 == fcode1
-                 && (fcode0 == BUILT_IN_EXP
-                     || fcode0 == BUILT_IN_EXPF
-                     || fcode0 == BUILT_IN_EXPL
-                     || fcode0 == BUILT_IN_EXP2
-                     || fcode0 == BUILT_IN_EXP2F
-                     || fcode0 == BUILT_IN_EXP2L
-                     || fcode0 == BUILT_IN_EXP10
-                     || fcode0 == BUILT_IN_EXP10F
-                     || fcode0 == BUILT_IN_EXP10L
-                     || fcode0 == BUILT_IN_POW10
-                     || fcode0 == BUILT_IN_POW10F
-                     || fcode0 == BUILT_IN_POW10L))
+             if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
                {
                  tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
                  tree arg = build (PLUS_EXPR, type,
@@ -6791,18 +6775,7 @@ fold (tree expr)
        {
          enum built_in_function fcode = builtin_mathfn_code (arg1);
          /* Optimize x/expN(y) into x*expN(-y).  */
-         if (fcode == BUILT_IN_EXP
-             || fcode == BUILT_IN_EXPF
-             || fcode == BUILT_IN_EXPL
-             || fcode == BUILT_IN_EXP2
-             || fcode == BUILT_IN_EXP2F
-             || fcode == BUILT_IN_EXP2L
-             || fcode == BUILT_IN_EXP10
-             || fcode == BUILT_IN_EXP10F
-             || fcode == BUILT_IN_EXP10L
-             || fcode == BUILT_IN_POW10
-             || fcode == BUILT_IN_POW10F
-             || fcode == BUILT_IN_POW10L)
+         if (BUILTIN_EXPONENT_P (fcode))
            {
              tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
              tree arg = build1 (NEGATE_EXPR, type,

diff --git a/gcc/tree.h b/gcc/tree.h
index bb36c92..0a1e3fb 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -101,6 +101,24 @@ enum built_in_function
 /* Names for the above.  */
 extern const char *const built_in_names[(int) END_BUILTINS];
 
+/* Helper macros for math builtins.  */
+
+#define BUILTIN_EXP10_P(FN) \
+ ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \
+  || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L)
+
+#define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \
+  || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \
+  || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L)
+
+#define BUILTIN_SQRT_P(FN) \
+ ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL)
+
+#define BUILTIN_CBRT_P(FN) \
+ ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL)
+
+#define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN))
+
 /* An array of _DECL trees for the above.  */
 extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
 extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];