OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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
This commit is contained in:
Richard Biener 2016-11-09 15:15:28 +00:00 committed by Richard Biener
parent 2c49f22a48
commit 14e7281244
10 changed files with 34 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
gcc/ChangeLog
View File

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

10
gcc/fold-const.c
View File

@ -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

2
gcc/fold-const.h
View File

@ -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 *);

2
gcc/genmatch.c
View File

@ -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",

4
gcc/gimple-fold.c
View File

@ -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);

8
gcc/gimple-match-head.c
View File

@ -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;

2
gcc/tree-ssa-dom.c
View File

@ -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

2
gcc/tree-ssa-reassoc.c
View File

@ -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);

4
gcc/tree-ssa-sccvn.c
View File

@ -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);

2
gcc/tree-ssa-threadedge.c
View File

@ -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);