From: Richard Guenther <rguenther@suse.de>
Date: Thu, 14 Jul 2011 14:21:07 +0000 (+0000)
Subject: gimple-fold.c (fold_gimple_assign): Remove operand swapping.
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=5fbcc0ed20ecdfd980106ac22607c5baed60d234;p=gcc.git

gimple-fold.c (fold_gimple_assign): Remove operand swapping.

2011-07-14  Richard Guenther  <rguenther@suse.de>

	* gimple-fold.c (fold_gimple_assign): Remove operand swapping.
	(fold_stmt_1): Do it here directly on gimple and as a first thing.

From-SVN: r176273
---

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 61b45357296..869214d5836 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,8 @@
+2011-07-14  Richard Guenther  <rguenther@suse.de>
+
+	* gimple-fold.c (fold_gimple_assign): Remove operand swapping.
+	(fold_stmt_1): Do it here directly on gimple and as a first thing.
+
 2011-07-14  Richard Guenther  <rguenther@suse.de>
 
 	* fold-const.c (fold_binary_loc): Convert the !bool_var result,
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 6b3b275eeee..bf00a0f0460 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -817,26 +817,15 @@ fold_gimple_assign (gimple_stmt_iterator *si)
 
       if (!result)
         result = fold_binary_loc (loc, subcode,
-                              TREE_TYPE (gimple_assign_lhs (stmt)),
-                              gimple_assign_rhs1 (stmt),
-                              gimple_assign_rhs2 (stmt));
+				  TREE_TYPE (gimple_assign_lhs (stmt)),
+				  gimple_assign_rhs1 (stmt),
+				  gimple_assign_rhs2 (stmt));
 
       if (result)
         {
           STRIP_USELESS_TYPE_CONVERSION (result);
           if (valid_gimple_rhs_p (result))
 	    return result;
-
-	  /* Fold might have produced non-GIMPLE, so if we trust it blindly
-	     we lose canonicalization opportunities.  Do not go again
-	     through fold here though, or the same non-GIMPLE will be
-	     produced.  */
-          if (commutative_tree_code (subcode)
-              && tree_swap_operands_p (gimple_assign_rhs1 (stmt),
-                                       gimple_assign_rhs2 (stmt), false))
-            return build2 (subcode, TREE_TYPE (gimple_assign_lhs (stmt)),
-                           gimple_assign_rhs2 (stmt),
-                           gimple_assign_rhs1 (stmt));
         }
       break;
 
@@ -852,18 +841,6 @@ fold_gimple_assign (gimple_stmt_iterator *si)
           STRIP_USELESS_TYPE_CONVERSION (result);
           if (valid_gimple_rhs_p (result))
 	    return result;
-
-	  /* Fold might have produced non-GIMPLE, so if we trust it blindly
-	     we lose canonicalization opportunities.  Do not go again
-	     through fold here though, or the same non-GIMPLE will be
-	     produced.  */
-          if (commutative_ternary_tree_code (subcode)
-              && tree_swap_operands_p (gimple_assign_rhs1 (stmt),
-                                       gimple_assign_rhs2 (stmt), false))
-            return build3 (subcode, TREE_TYPE (gimple_assign_lhs (stmt)),
-			   gimple_assign_rhs2 (stmt),
-			   gimple_assign_rhs1 (stmt),
-			   gimple_assign_rhs3 (stmt));
         }
       break;
 
@@ -1576,8 +1553,22 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace)
     case GIMPLE_ASSIGN:
       {
 	unsigned old_num_ops = gimple_num_ops (stmt);
-	tree new_rhs = fold_gimple_assign (gsi);
+	enum tree_code subcode = gimple_assign_rhs_code (stmt);
 	tree lhs = gimple_assign_lhs (stmt);
+	tree new_rhs;
+	/* First canonicalize operand order.  This avoids building new
+	   trees if this is the only thing fold would later do.  */
+	if ((commutative_tree_code (subcode)
+	     || commutative_ternary_tree_code (subcode))
+	    && tree_swap_operands_p (gimple_assign_rhs1 (stmt),
+				     gimple_assign_rhs2 (stmt), false))
+	  {
+	    tree tem = gimple_assign_rhs1 (stmt);
+	    gimple_assign_set_rhs1 (stmt, gimple_assign_rhs2 (stmt));
+	    gimple_assign_set_rhs2 (stmt, tem);
+	    changed = true;
+	  }
+	new_rhs = fold_gimple_assign (gsi);
 	if (new_rhs
 	    && !useless_type_conversion_p (TREE_TYPE (lhs),
 					   TREE_TYPE (new_rhs)))