Bootstrapped on x86_64-unknown-linux-gnu, testing in progress.
Richard.
2016-11-09 Richard Biener <rguent...@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.
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 603aff0..a774848 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -9159,13 +9159,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);
@@ -11271,7 +11271,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);
@@ -11400,7 +11400,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 ae37142..46dcd28 100644
--- 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 b14034d..41951c5 100644
--- 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 5d46405..aabc8ff 100644
--- 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 4eab90d..09f729f 100644
--- 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 5376ff9..f1dbb4c 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -1179,7 +1179,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 5dcf672..f781c5f 100644
--- 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 00c1c23..e25f070 100644
--- 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 170e456..534292c 100644
--- 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);
