fold-const.c (tree_swap_operands_p): Remove unused arg.

2016-11-09  Richard Biener  <rguenther@suse.de>

	* fold-const.c (tree_swap_operands_p): Remove unused arg.
	* fold-const.c (tree_swap_operands_p): Likewise.
	(fold_binary_loc): Adjust.
	(fold_ternary_loc): Likewise.
	* genmatch.c (dt_operand::gen_gimple_exp): Likewise.
	* gimple-fold.c (fold_stmt_1): Likewise.
	* gimple-match-head.c (gimple_resimplify2): Likewise.
	(gimple_resimplify3): Likewise.
	(gimple_simplify): Likewise.
	* tree-ssa-dom.c (record_equality): Likewise.
	* tree-ssa-reassoc.c (optimize_range_tests_var_bound): Likewise.
	* tree-ssa-sccvn.c (vn_nary_op_compute_hash): Likewise.
	* tree-ssa-threadedge.c (simplify_control_stmt_condition_1): Likewise.

From-SVN: r242004

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 4868c8fa610f0c9fb1baa7b8476c55321bbc07d8..2188dbfe5e360a4ae234e1daeeb30188e0b3aea6 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,19 @@
+2016-11-09  Richard Biener  <rguenther@suse.de>
+
+       * fold-const.c (tree_swap_operands_p): Remove unused arg.
+       * fold-const.c (tree_swap_operands_p): Likewise.
+       (fold_binary_loc): Adjust.
+       (fold_ternary_loc): Likewise.
+       * genmatch.c (dt_operand::gen_gimple_exp): Likewise.
+       * gimple-fold.c (fold_stmt_1): Likewise.
+       * gimple-match-head.c (gimple_resimplify2): Likewise.
+       (gimple_resimplify3): Likewise.
+       (gimple_simplify): Likewise.
+       * tree-ssa-dom.c (record_equality): Likewise.
+       * tree-ssa-reassoc.c (optimize_range_tests_var_bound): Likewise.
+       * tree-ssa-sccvn.c (vn_nary_op_compute_hash): Likewise.
+       * tree-ssa-threadedge.c (simplify_control_stmt_condition_1): Likewise.
+
 2016-11-09  Richard Biener  <rguenther@suse.de>
 
        * tree-ssa-dom.c (canonicalize_comparison): Remove.

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index b78b6d855a14836ca327e1b932563d39a13020fb..e14471ed8d35c66d97223b70bfd21973cd1b29d0 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -6758,7 +6758,7 @@ fold_single_bit_test (location_t loc, enum tree_code code,
    isn't.  */
 
 bool
-tree_swap_operands_p (const_tree arg0, const_tree arg1, bool)
+tree_swap_operands_p (const_tree arg0, const_tree arg1)
 {
   if (CONSTANT_CLASS_P (arg1))
     return 0;
@@ -9132,13 +9132,13 @@ fold_binary_loc (location_t loc,
   /* If this is a commutative operation, and ARG0 is a constant, move it
      to ARG1 to reduce the number of tests below.  */
   if (commutative_tree_code (code)
-      && tree_swap_operands_p (arg0, arg1, true))
+      && tree_swap_operands_p (arg0, arg1))
     return fold_build2_loc (loc, code, type, op1, op0);
 
   /* Likewise if this is a comparison, and ARG0 is a constant, move it
      to ARG1 to reduce the number of tests below.  */
   if (kind == tcc_comparison
-      && tree_swap_operands_p (arg0, arg1, true))
+      && tree_swap_operands_p (arg0, arg1))
     return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
 
   tem = generic_simplify (loc, code, type, op0, op1);
@@ -11242,7 +11242,7 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type,
   /* If this is a commutative operation, and OP0 is a constant, move it
      to OP1 to reduce the number of tests below.  */
   if (commutative_ternary_tree_code (code)
-      && tree_swap_operands_p (op0, op1, true))
+      && tree_swap_operands_p (op0, op1))
     return fold_build3_loc (loc, code, type, op1, op0, op2);
 
   tem = generic_simplify (loc, code, type, op0, op1, op2);
@@ -11371,7 +11371,7 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type,
       /* If the second operand is simpler than the third, swap them
         since that produces better jump optimization results.  */
       if (truth_value_p (TREE_CODE (arg0))
-         && tree_swap_operands_p (op1, op2, false))
+         && tree_swap_operands_p (op1, op2))
        {
          location_t loc0 = expr_location_or (arg0, loc);
          /* See if this can be inverted.  If it can't, possibly because

diff --git a/gcc/fold-const.h b/gcc/fold-const.h
index ae37142bb843e558bb2fd644f75c30ffb08052d5..46dcd2878296877a712845afb5a02018a26b9ca7 100644 (file)
--- a/gcc/fold-const.h
+++ b/gcc/fold-const.h
@@ -124,7 +124,7 @@ extern tree build_invariant_address (tree, tree, HOST_WIDE_INT);
 extern tree constant_boolean_node (bool, tree);
 extern tree div_if_zero_remainder (const_tree, const_tree);
 
-extern bool tree_swap_operands_p (const_tree, const_tree, bool);
+extern bool tree_swap_operands_p (const_tree, const_tree);
 extern enum tree_code swap_tree_comparison (enum tree_code);
 
 extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *);

diff --git a/gcc/genmatch.c b/gcc/genmatch.c
index b14034deb7c53f4857ccc2b8dad697d9c92ed9c9..41951c57940e6d4384f74a9f6711895b16902941 100644 (file)
--- a/gcc/genmatch.c
+++ b/gcc/genmatch.c
@@ -2701,7 +2701,7 @@ dt_operand::gen_gimple_expr (FILE *f, int indent)
          gen_opname (child_opname0, 0);
          gen_opname (child_opname1, 1);
          fprintf_indent (f, indent,
-                         "if (tree_swap_operands_p (%s, %s, false))\n",
+                         "if (tree_swap_operands_p (%s, %s))\n",
                          child_opname0, child_opname1);
          fprintf_indent (f, indent,
                          "  std::swap (%s, %s);\n",

diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 5d464055a8359879ace52f4b24dd0a451fa212f6..aabc8ff2a7192b088e0258e07ef61f8c699d9059 100644 (file)
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -4166,7 +4166,7 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree))
            {
              tree rhs1 = gimple_assign_rhs1 (stmt);
              tree rhs2 = gimple_assign_rhs2 (stmt);
-             if (tree_swap_operands_p (rhs1, rhs2, false))
+             if (tree_swap_operands_p (rhs1, rhs2))
                {
                  gimple_assign_set_rhs1 (stmt, rhs2);
                  gimple_assign_set_rhs2 (stmt, rhs1);
@@ -4232,7 +4232,7 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree))
        /* Canonicalize operand order.  */
        tree lhs = gimple_cond_lhs (stmt);
        tree rhs = gimple_cond_rhs (stmt);
-       if (tree_swap_operands_p (lhs, rhs, false))
+       if (tree_swap_operands_p (lhs, rhs))
          {
            gcond *gc = as_a <gcond *> (stmt);
            gimple_cond_set_lhs (gc, rhs);

diff --git a/gcc/gimple-match-head.c b/gcc/gimple-match-head.c
index 4eab90d8f6debb7d34b095fed4b9e4eafd82cd1f..09f729f62fd42c53170a64530a0eda8bd514ee2f 100644 (file)
--- a/gcc/gimple-match-head.c
+++ b/gcc/gimple-match-head.c
@@ -151,7 +151,7 @@ gimple_resimplify2 (gimple_seq *seq,
   if (res_code->is_tree_code ()
       && (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison
          || commutative_tree_code (*res_code))
-      && tree_swap_operands_p (res_ops[0], res_ops[1], false))
+      && tree_swap_operands_p (res_ops[0], res_ops[1]))
     {
       std::swap (res_ops[0], res_ops[1]);
       if (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison)
@@ -212,7 +212,7 @@ gimple_resimplify3 (gimple_seq *seq,
   bool canonicalized = false;
   if (res_code->is_tree_code ()
       && commutative_ternary_tree_code (*res_code)
-      && tree_swap_operands_p (res_ops[0], res_ops[1], false))
+      && tree_swap_operands_p (res_ops[0], res_ops[1]))
     {
       std::swap (res_ops[0], res_ops[1]);
       canonicalized = true;
@@ -432,7 +432,7 @@ gimple_simplify (enum tree_code code, tree type,
      generation.  */
   if ((commutative_tree_code (code)
        || TREE_CODE_CLASS (code) == tcc_comparison)
-      && tree_swap_operands_p (op0, op1, false))
+      && tree_swap_operands_p (op0, op1))
     {
       std::swap (op0, op1);
       if (TREE_CODE_CLASS (code) == tcc_comparison)
@@ -466,7 +466,7 @@ gimple_simplify (enum tree_code code, tree type,
   /* Canonicalize operand order both for matching and fallback stmt
      generation.  */
   if (commutative_ternary_tree_code (code)
-      && tree_swap_operands_p (op0, op1, false))
+      && tree_swap_operands_p (op0, op1))
     std::swap (op0, op1);
 
   code_helper rcode;

diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 85689f3d93f009e34653e7867e794f9fd179ebe0..1839c8a20e53a01e45070cb5a9369a673efd4efd 100644 (file)
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -1136,7 +1136,7 @@ record_equality (tree x, tree y, class const_and_copies *const_and_copies)
 {
   tree prev_x = NULL, prev_y = NULL;
 
-  if (tree_swap_operands_p (x, y, false))
+  if (tree_swap_operands_p (x, y))
     std::swap (x, y);
 
   /* Most of the time tree_swap_operands_p does what we want.  But there

diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c
index 5dcf6720605456251221885b9f278f99423a287f..f781c5ff28c4f3aee0e7cfd3aae31f403dd28795 100644 (file)
--- a/gcc/tree-ssa-reassoc.c
+++ b/gcc/tree-ssa-reassoc.c
@@ -2980,7 +2980,7 @@ optimize_range_tests_var_bound (enum tree_code opcode, int first, int length,
       gimple_set_uid (g, uid);
       rhs2 = gimple_assign_lhs (g);
       gsi_insert_before (&gsi, g, GSI_SAME_STMT);
-      if (tree_swap_operands_p (rhs1, rhs2, false))
+      if (tree_swap_operands_p (rhs1, rhs2))
        {
          std::swap (rhs1, rhs2);
          ccode = swap_tree_comparison (ccode);

diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c
index 00c1c23054346ef075c34446eee2e0acb1feaa50..e25f07066d1e6aab1b14178e4120b52976c24ffb 100644 (file)
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -2580,10 +2580,10 @@ vn_nary_op_compute_hash (const vn_nary_op_t vno1)
        && commutative_tree_code (vno1->opcode))
        || (vno1->length == 3
           && commutative_ternary_tree_code (vno1->opcode)))
-      && tree_swap_operands_p (vno1->op[0], vno1->op[1], false))
+      && tree_swap_operands_p (vno1->op[0], vno1->op[1]))
     std::swap (vno1->op[0], vno1->op[1]);
   else if (TREE_CODE_CLASS (vno1->opcode) == tcc_comparison
-          && tree_swap_operands_p (vno1->op[0], vno1->op[1], false))
+          && tree_swap_operands_p (vno1->op[0], vno1->op[1]))
     {
       std::swap (vno1->op[0], vno1->op[1]);
       vno1->opcode = swap_tree_comparison  (vno1->opcode);

diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index 170e4564b559a09a86eb32318d6f62bc86fd3ad7..534292c19e5a4ce3c6b0ae129adcacdc9635bc89 100644 (file)
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -564,7 +564,7 @@ simplify_control_stmt_condition_1 (edge e,
      example, op0 might be a constant while op1 is an
      SSA_NAME.  Failure to canonicalize will cause us to
      miss threading opportunities.  */
-  if (tree_swap_operands_p (op0, op1, false))
+  if (tree_swap_operands_p (op0, op1))
     {
       cond_code = swap_tree_comparison (cond_code);
       std::swap (op0, op1);