fold-const.c (nondestructive_fold_binary_to_constant): Rename to fold_binary_to_constant.

	* fold-const.c (nondestructive_fold_binary_to_constant): Rename
	to fold_binary_to_constant.
	(nondestructive_fold_unary_to_constant): Likewise, rename to
	fold_unary_to_constant.
	(fold_relational_hi_lo): Update call to fold_binary_to_constant.
	* tree.h (nondestructive_fold_binary_to_constant): Update prototype.
	(nondestructive_fold_unary_to_constant): Likewise.
	* tree-ssa-ccp.c (ccp_fold): Update calls to fold_unary_to_constant
	and fold_binary_to_constant.
	* tree-ssa-loop-niter.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
	(inverse, number_of_iterations_cond): Replace uses of EXEC_BINARY
	and EXEC_UNARY with calls to fold_*nary_to_constant.
	* tree-ssa-loop-ivopts.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
	(idx_find_step): Replace uses of EXEC_BINARY with calls to
	fold_binary_to_constant.

From-SVN: r91063

gcc/ChangeLog

 2004-11-22  Roger Sayle  <roger@eyesopen.com>
 
+	* fold-const.c (nondestructive_fold_binary_to_constant): Rename
+	to fold_binary_to_constant.
+	(nondestructive_fold_unary_to_constant): Likewise, rename to
+	fold_unary_to_constant.
+	(fold_relational_hi_lo): Update call to fold_binary_to_constant.
+	* tree.h (nondestructive_fold_binary_to_constant): Update prototype.
+	(nondestructive_fold_unary_to_constant): Likewise.
+	* tree-ssa-ccp.c (ccp_fold): Update calls to fold_unary_to_constant
+	and fold_binary_to_constant.
+	* tree-ssa-loop-niter.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
+	(inverse, number_of_iterations_cond): Replace uses of EXEC_BINARY
+	and EXEC_UNARY with calls to fold_*nary_to_constant.
+	* tree-ssa-loop-ivopts.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
+	(idx_find_step): Replace uses of EXEC_BINARY with calls to
+	fold_binary_to_constant.
+
+2004-11-22  Roger Sayle  <roger@eyesopen.com>
+
 	* config/i386/i386.h (TARGET_USE_FANCY_MATH_387): New macro.
 	* config/i386/i386.c (override_options):  Set MASK_NO_FANCY_MATH_387
 	automatically for targets without TARGET_80387.

gcc/fold-const.c

@@ -10110,11 +10110,10 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
 			    fold_convert (st0, op0),
 			    fold_convert (st1, integer_zero_node));
 
-	      retval
-		= nondestructive_fold_binary_to_constant (TREE_CODE (exp),
-							  TREE_TYPE (exp),
-							  TREE_OPERAND (exp, 0),
-							  TREE_OPERAND (exp, 1));
+	      retval = fold_binary_to_constant (TREE_CODE (exp),
+						TREE_TYPE (exp),
+						TREE_OPERAND (exp, 0),
+						TREE_OPERAND (exp, 1));
 
 	      /* If we are in gimple form, then returning EXP would create
 		 non-gimple expressions.  Clearing it is safe and insures
@@ -10145,8 +10144,7 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
    simpler than the generic fold routine.  */
 
 tree
-nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
-					tree op0, tree op1)
+fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
 {
   int wins = 1;
   tree subop0;
@@ -10440,8 +10438,7 @@ nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
    the generic fold routine.  */
 
 tree
-nondestructive_fold_unary_to_constant (enum tree_code code, tree type,
-				       tree op0)
+fold_unary_to_constant (enum tree_code code, tree type, tree op0)
 {
   /* Make sure we have a suitable constant argument.  */
   if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)

gcc/tree-ssa-ccp.c

@@ -847,9 +847,7 @@ ccp_fold (tree stmt)
 	    op0 = get_value (op0)->const_val;
 	}
 
-      retval = nondestructive_fold_unary_to_constant (code,
-		     				      TREE_TYPE (rhs),
-						      op0);
+      retval = fold_unary_to_constant (code, TREE_TYPE (rhs), op0);
 
       /* If we folded, but did not create an invariant, then we can not
 	 use this expression.  */
@@ -900,9 +898,7 @@ ccp_fold (tree stmt)
 	    op1 = val->const_val;
 	}
 
-      retval = nondestructive_fold_binary_to_constant (code,
-		     				       TREE_TYPE (rhs),
-						       op0, op1);
+      retval = fold_binary_to_constant (code, TREE_TYPE (rhs), op0, op1);
 
       /* If we folded, but did not create an invariant, then we can not
 	 use this expression.  */

gcc/tree-ssa-loop-ivopts.c

@@ -96,9 +96,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    this.  */
 #define AVG_LOOP_NITER(LOOP) 5
 
-/* Just to shorten the ugly names.  */
-#define EXEC_BINARY nondestructive_fold_binary_to_constant
-#define EXEC_UNARY nondestructive_fold_unary_to_constant
 
 /* Representation of the induction variable.  */
 struct iv
@@ -1364,12 +1361,13 @@ idx_find_step (tree base, tree *idx, void *data)
       return false;
     }
 
-  step = EXEC_BINARY (MULT_EXPR, type, step, iv_step);
+  step = fold_binary_to_constant (MULT_EXPR, type, step, iv_step);
 
   if (!*dta->step_p)
     *dta->step_p = step;
   else
-    *dta->step_p = EXEC_BINARY (PLUS_EXPR, type, *dta->step_p, step);
+    *dta->step_p = fold_binary_to_constant (PLUS_EXPR, type,
+					    *dta->step_p, step);
 
   return true;
 }

gcc/tree-ssa-loop-niter.c

@@ -43,9 +43,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 #define SWAP(X, Y) do { void *tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
 
-/* Just to shorten the ugly names.  */
-#define EXEC_BINARY nondestructive_fold_binary_to_constant
-#define EXEC_UNARY nondestructive_fold_unary_to_constant
 
 /*
 
@@ -156,10 +153,10 @@ inverse (tree x, tree mask)
       rslt = build_int_cst_type (type, 1);
       for (; ctr; ctr--)
 	{
-	  rslt = EXEC_BINARY (MULT_EXPR, type, rslt, x);
-	  x = EXEC_BINARY (MULT_EXPR, type, x, x);
+	  rslt = fold_binary_to_constant (MULT_EXPR, type, rslt, x);
+	  x = fold_binary_to_constant (MULT_EXPR, type, x, x);
 	}
-      rslt = EXEC_BINARY (BIT_AND_EXPR, type, rslt, mask);
+      rslt = fold_binary_to_constant (BIT_AND_EXPR, type, rslt, mask);
     }
 
   return rslt;
@@ -217,7 +214,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
       if (code != NE_EXPR)
 	return;
 
-      step0 = EXEC_BINARY (MINUS_EXPR, type, step0, step1);
+      step0 = fold_binary_to_constant (MINUS_EXPR, type, step0, step1);
       step1 = NULL_TREE;
     }
 
@@ -311,7 +308,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
   if (code != NE_EXPR)
     {
       if (zero_p (step0))
-	step = EXEC_UNARY (NEGATE_EXPR, type, step1);
+	step = fold_unary_to_constant (NEGATE_EXPR, type, step1);
       else
 	step = step0;
       delta = build2 (MINUS_EXPR, type, base1, base0);
@@ -320,8 +317,8 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
 
       if (TREE_CODE (delta) == INTEGER_CST)
 	{
-	  tmp = EXEC_BINARY (MINUS_EXPR, type, step,
-			     build_int_cst_type (type, 1));
+	  tmp = fold_binary_to_constant (MINUS_EXPR, type, step,
+					 build_int_cst_type (type, 1));
 	  if (was_sharp
 	      && operand_equal_p (delta, tmp, 0))
 	    {
@@ -342,8 +339,10 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
 		may_xform = boolean_true_node;
 	      else
 		{
-		  bound = EXEC_BINARY (PLUS_EXPR, type, mmin, step);
-		  bound = EXEC_BINARY (MINUS_EXPR, type, bound, delta);
+		  bound = fold_binary_to_constant (PLUS_EXPR, type,
+						   mmin, step);
+		  bound = fold_binary_to_constant (MINUS_EXPR, type,
+						   bound, delta);
 		  may_xform = fold (build2 (LE_EXPR, boolean_type_node,
 					   bound, base0));
 		}
@@ -354,8 +353,10 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
 		may_xform = boolean_true_node;
 	      else
 		{
-		  bound = EXEC_BINARY (MINUS_EXPR, type, mmax, step);
-		  bound = EXEC_BINARY (PLUS_EXPR, type, bound, delta);
+		  bound = fold_binary_to_constant (MINUS_EXPR, type,
+						   mmax, step);
+		  bound = fold_binary_to_constant (PLUS_EXPR, type,
+						   bound, delta);
 		  may_xform = fold (build2 (LE_EXPR, boolean_type_node,
 					   base1, bound));
 		}
@@ -401,11 +402,11 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
       base1 = fold (build2 (MINUS_EXPR, type, base1, base0));
       base0 = NULL_TREE;
       if (!zero_p (step1))
-  	step0 = EXEC_UNARY (NEGATE_EXPR, type, step1);
+  	step0 = fold_unary_to_constant (NEGATE_EXPR, type, step1);
       step1 = NULL_TREE;
       if (!tree_expr_nonnegative_p (fold_convert (signed_niter_type, step0)))
 	{
-	  step0 = EXEC_UNARY (NEGATE_EXPR, type, step0);
+	  step0 = fold_unary_to_constant (NEGATE_EXPR, type, step0);
 	  base1 = fold (build1 (NEGATE_EXPR, type, base1));
 	}
 
@@ -416,9 +417,9 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
 	 is infinite.  Otherwise, the number of iterations is
 	 (inverse(s/d) * (c/d)) mod (size of mode/d).  */
       bits = num_ending_zeros (step0);
-      d = EXEC_BINARY (LSHIFT_EXPR, niter_type,
-		       build_int_cst_type (niter_type, 1), bits);
-      s = EXEC_BINARY (RSHIFT_EXPR, niter_type, step0, bits);
+      d = fold_binary_to_constant (LSHIFT_EXPR, niter_type,
+				   build_int_cst_type (niter_type, 1), bits);
+      s = fold_binary_to_constant (RSHIFT_EXPR, niter_type, step0, bits);
 
       bound = build_low_bits_mask (niter_type,
 				   (TYPE_PRECISION (niter_type)
@@ -447,7 +448,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
 	{
 	  if (mmax)
 	    {
-	      bound = EXEC_BINARY (MINUS_EXPR, type, mmax, step0);
+	      bound = fold_binary_to_constant (MINUS_EXPR, type, mmax, step0);
 	      assumption = fold (build2 (LE_EXPR, boolean_type_node,
 					 base1, bound));
 	      assumptions = fold (build2 (TRUTH_AND_EXPR, boolean_type_node,
@@ -468,7 +469,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
 	     we can again compute number of iterations as (b - (a - s)) / s.  */
 	  if (mmin)
 	    {
-	      bound = EXEC_BINARY (MINUS_EXPR, type, mmin, step1);
+	      bound = fold_binary_to_constant (MINUS_EXPR, type, mmin, step1);
 	      assumption = fold (build2 (LE_EXPR, boolean_type_node,
 					bound, base0));
 	      assumptions = fold (build2 (TRUTH_AND_EXPR, boolean_type_node,

gcc/tree.h

@@ -3525,8 +3525,8 @@ extern int operand_equal_p (tree, tree, unsigned int);
 extern tree omit_one_operand (tree, tree, tree);
 extern tree omit_two_operands (tree, tree, tree, tree);
 extern tree invert_truthvalue (tree);
-extern tree nondestructive_fold_unary_to_constant (enum tree_code, tree, tree);
-extern tree nondestructive_fold_binary_to_constant (enum tree_code, tree, tree, tree);
+extern tree fold_unary_to_constant (enum tree_code, tree, tree);
+extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree);
 extern tree fold_read_from_constant_string (tree);
 extern tree int_const_binop (enum tree_code, tree, tree, int);
 extern tree build_fold_addr_expr (tree);