tree.h (BUILTIN_EXP10_P, [...]): New macros.

	* 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.

From-SVN: r79023

4 files changed, 37 insertions, 49 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 423ff63..84824f9 100644
--- 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
--- 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
--- 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
--- 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];