Skip to content

R
riscv-gcc-1
Commit 4c707980 by Kugan Vivekanandarajah Committed by Kugan Vivekanandarajah
Options

revert: re PR tree-optimization/66726 (missed optimization, factor conversion out of COND_EXPR) 

2016-02-12  Kugan Vivekanandarajah  <kuganv@linaro.org>

	revert:
	2016-02-12  Kugan Vivekanandarajah  <kuganv@linaro.org>

	PR middle-end/66726
	* tree-ssa-reassoc.c (optimize_range_tests): Handle tcc_compare stmt
	whose result is used in PHI.
	(maybe_optimize_range_tests): Likewise.
	(final_range_test_p): Likweise.

From-SVN: r233368
parent f48dfe98
Showing with 35 additions and 110 deletions
gcc/ChangeLog
2016-02-12 Kugan Vivekanandarajah <kuganv@linaro.org> 2016-02-12 Kugan Vivekanandarajah <kuganv@linaro.org>
revert:
2016-02-12 Kugan Vivekanandarajah <kuganv@linaro.org>
PR middle-end/66726
* tree-ssa-reassoc.c (optimize_range_tests): Handle tcc_compare stmt
whose result is used in PHI.
(maybe_optimize_range_tests): Likewise.
(final_range_test_p): Likweise.
2016-02-12 Kugan Vivekanandarajah <kuganv@linaro.org>
PR middle-end/66726 PR middle-end/66726
* tree-ssa-reassoc.c (optimize_range_tests): Handle tcc_compare stmt * tree-ssa-reassoc.c (optimize_range_tests): Handle tcc_compare stmt
whose result is used in PHI. whose result is used in PHI.
......
gcc/tree-ssa-reassoc.c
...@@ -2687,33 +2687,18 @@ optimize_range_tests (enum tree_code opcode, ...@@ -2687,33 +2687,18 @@ optimize_range_tests (enum tree_code opcode,
# _345 = PHI <_123(N), 1(...), 1(...)> # _345 = PHI <_123(N), 1(...), 1(...)>
where _234 has bool type, _123 has single use and where _234 has bool type, _123 has single use and
bb N has a single successor M. This is commonly used in bb N has a single successor M. This is commonly used in
the last block of a range test.
Also Return true if STMT is tcc_compare like:
<bb N>:
...
_234 = a_2(D) == 2;
<bb M>:
# _345 = PHI <_234(N), 1(...), 1(...)>
_346 = (int) _345;
where _234 has booltype, single use and
bb N has a single successor M. This is commonly used in
the last block of a range test. */ the last block of a range test. */
static bool static bool
final_range_test_p (gimple *stmt) final_range_test_p (gimple *stmt)
{ {
basic_block bb, rhs_bb, lhs_bb; basic_block bb, rhs_bb;
edge e; edge e;
tree lhs, rhs; tree lhs, rhs;
use_operand_p use_p; use_operand_p use_p;
gimple *use_stmt; gimple *use_stmt;
if (!gimple_assign_cast_p (stmt) if (!gimple_assign_cast_p (stmt))
&& (!is_gimple_assign (stmt)
|| (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))
!= tcc_comparison)))
return false; return false;
bb = gimple_bb (stmt); bb = gimple_bb (stmt);
if (!single_succ_p (bb)) if (!single_succ_p (bb))
...@@ -2724,16 +2709,11 @@ final_range_test_p (gimple *stmt) ...@@ -2724,16 +2709,11 @@ final_range_test_p (gimple *stmt)
lhs = gimple_assign_lhs (stmt); lhs = gimple_assign_lhs (stmt);
rhs = gimple_assign_rhs1 (stmt); rhs = gimple_assign_rhs1 (stmt);
if (gimple_assign_cast_p (stmt) if (!INTEGRAL_TYPE_P (TREE_TYPE (lhs))
&& (!INTEGRAL_TYPE_P (TREE_TYPE (lhs)) || TREE_CODE (rhs) != SSA_NAME
|| TREE_CODE (rhs) != SSA_NAME || TREE_CODE (TREE_TYPE (rhs)) != BOOLEAN_TYPE)
|| TREE_CODE (TREE_TYPE (rhs)) != BOOLEAN_TYPE))
return false; return false;
if (!gimple_assign_cast_p (stmt)
&& (TREE_CODE (TREE_TYPE (lhs)) != BOOLEAN_TYPE))
return false;
/* Test whether lhs is consumed only by a PHI in the only successor bb. */ /* Test whether lhs is consumed only by a PHI in the only successor bb. */
if (!single_imm_use (lhs, &use_p, &use_stmt)) if (!single_imm_use (lhs, &use_p, &use_stmt))
return false; return false;
...@@ -2743,20 +2723,10 @@ final_range_test_p (gimple *stmt) ...@@ -2743,20 +2723,10 @@ final_range_test_p (gimple *stmt)
return false; return false;
/* And that the rhs is defined in the same loop. */ /* And that the rhs is defined in the same loop. */
if (gimple_assign_cast_p (stmt)) rhs_bb = gimple_bb (SSA_NAME_DEF_STMT (rhs));
{ if (rhs_bb == NULL
if (TREE_CODE (rhs) != SSA_NAME || !flow_bb_inside_loop_p (loop_containing_stmt (stmt), rhs_bb))
|| !(rhs_bb = gimple_bb (SSA_NAME_DEF_STMT (rhs))) return false;
|| !flow_bb_inside_loop_p (loop_containing_stmt (stmt), rhs_bb))
return false;
}
else
{
if (TREE_CODE (lhs) != SSA_NAME
|| !(lhs_bb = gimple_bb (SSA_NAME_DEF_STMT (lhs)))
|| !flow_bb_inside_loop_p (loop_containing_stmt (stmt), lhs_bb))
return false;
}
return true; return true;
} }
...@@ -3149,8 +3119,6 @@ maybe_optimize_range_tests (gimple *stmt) ...@@ -3149,8 +3119,6 @@ maybe_optimize_range_tests (gimple *stmt)
/* stmt is /* stmt is
_123 = (int) _234; _123 = (int) _234;
OR
_234 = a_2(D) == 2;
followed by: followed by:
<bb M>: <bb M>:
...@@ -3180,8 +3148,6 @@ maybe_optimize_range_tests (gimple *stmt) ...@@ -3180,8 +3148,6 @@ maybe_optimize_range_tests (gimple *stmt)
of the bitwise or resp. and, recursively. */ of the bitwise or resp. and, recursively. */
if (!get_ops (rhs, code, &ops, if (!get_ops (rhs, code, &ops,
loop_containing_stmt (stmt)) loop_containing_stmt (stmt))
&& (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))
!= tcc_comparison)
&& has_single_use (rhs)) && has_single_use (rhs))
{ {
/* Otherwise, push the _234 range test itself. */ /* Otherwise, push the _234 range test itself. */
...@@ -3194,23 +3160,6 @@ maybe_optimize_range_tests (gimple *stmt) ...@@ -3194,23 +3160,6 @@ maybe_optimize_range_tests (gimple *stmt)
ops.safe_push (oe); ops.safe_push (oe);
bb_ent.last_idx++; bb_ent.last_idx++;
} }
else if (!get_ops (lhs, code, &ops,
loop_containing_stmt (stmt))
&& TREE_CODE (lhs) == SSA_NAME
&& INTEGRAL_TYPE_P (TREE_TYPE (lhs))
&& is_gimple_assign (stmt)
&& (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))
== tcc_comparison)
&& has_single_use (lhs))
{
operand_entry *oe = operand_entry_pool.allocate ();
oe->op = lhs;
oe->rank = code;
oe->id = 0;
oe->count = 1;
ops.safe_push (oe);
bb_ent.last_idx++;
}
else else
bb_ent.last_idx = ops.length (); bb_ent.last_idx = ops.length ();
bb_ent.op = rhs; bb_ent.op = rhs;
...@@ -3294,60 +3243,26 @@ maybe_optimize_range_tests (gimple *stmt) ...@@ -3294,60 +3243,26 @@ maybe_optimize_range_tests (gimple *stmt)
{ {
imm_use_iterator iter; imm_use_iterator iter;
use_operand_p use_p; use_operand_p use_p;
gimple *use_stmt, *cast_or_tcc_cmp_stmt = NULL; gimple *use_stmt, *cast_stmt = NULL;
FOR_EACH_IMM_USE_STMT (use_stmt, iter, bbinfo[idx].op) FOR_EACH_IMM_USE_STMT (use_stmt, iter, bbinfo[idx].op)
if (is_gimple_debug (use_stmt) if (is_gimple_debug (use_stmt))
|| (TREE_CODE (new_op) == SSA_NAME
&& !reassoc_stmt_dominates_stmt_p
(SSA_NAME_DEF_STMT (new_op), use_stmt)))
continue; continue;
else if (gimple_code (use_stmt) == GIMPLE_PHI) else if (gimple_code (use_stmt) == GIMPLE_COND
FOR_EACH_IMM_USE_ON_STMT (use_p, iter) || gimple_code (use_stmt) == GIMPLE_PHI)
SET_USE (use_p, new_op); FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
else if (gimple_code (use_stmt) == GIMPLE_COND) SET_USE (use_p, new_op);
{
tree new_type, new_lhs;
gassign *g;
gcond *cond_stmt = as_a <gcond *> (use_stmt);
new_type = TREE_TYPE (gimple_cond_lhs (cond_stmt));
if (!types_compatible_p (new_type, TREE_TYPE (new_op)))
{
new_lhs = make_ssa_name (new_type);
if (is_gimple_min_invariant (new_op))
{
new_op = fold_convert (new_type, new_op);
g = gimple_build_assign (new_lhs, new_op);
}
else
g = gimple_build_assign (new_lhs,
CONVERT_EXPR, new_op);
gimple_stmt_iterator gsi = gsi_for_stmt (use_stmt);
gimple_set_uid (g, gimple_uid (use_stmt));
gimple_set_visited (g, true);
gsi_insert_before (&gsi, g, GSI_SAME_STMT);
}
else
new_lhs = new_op;
FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
SET_USE (use_p, new_lhs);
}
else if ((is_gimple_assign (use_stmt)
&& (TREE_CODE_CLASS (gimple_assign_rhs_code (use_stmt)) == tcc_comparison)))
{
cast_or_tcc_cmp_stmt = use_stmt;
}
else if (gimple_assign_cast_p (use_stmt)) else if (gimple_assign_cast_p (use_stmt))
cast_or_tcc_cmp_stmt = use_stmt; cast_stmt = use_stmt;
else
if (cast_or_tcc_cmp_stmt) gcc_unreachable ();
if (cast_stmt)
{ {
gcc_assert (bb == last_bb); gcc_assert (bb == last_bb);
tree lhs = gimple_assign_lhs (cast_or_tcc_cmp_stmt); tree lhs = gimple_assign_lhs (cast_stmt);
tree new_lhs = make_ssa_name (TREE_TYPE (lhs)); tree new_lhs = make_ssa_name (TREE_TYPE (lhs));
enum tree_code rhs_code enum tree_code rhs_code
= gimple_assign_cast_p (cast_or_tcc_cmp_stmt) ? = gimple_assign_rhs_code (cast_stmt);
gimple_assign_rhs_code (cast_or_tcc_cmp_stmt) : CONVERT_EXPR;
gassign *g; gassign *g;
if (is_gimple_min_invariant (new_op)) if (is_gimple_min_invariant (new_op))
{ {
...@@ -3356,14 +3271,13 @@ maybe_optimize_range_tests (gimple *stmt) ...@@ -3356,14 +3271,13 @@ maybe_optimize_range_tests (gimple *stmt)
} }
else else
g = gimple_build_assign (new_lhs, rhs_code, new_op); g = gimple_build_assign (new_lhs, rhs_code, new_op);
gimple_stmt_iterator gsi = gsi_for_stmt (cast_or_tcc_cmp_stmt); gimple_stmt_iterator gsi = gsi_for_stmt (cast_stmt);
gimple_set_uid (g, gimple_uid (cast_or_tcc_cmp_stmt)); gimple_set_uid (g, gimple_uid (cast_stmt));
gimple_set_visited (g, true); gimple_set_visited (g, true);
gsi_insert_after (&gsi, g, GSI_SAME_STMT); gsi_insert_before (&gsi, g, GSI_SAME_STMT);
FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
if (is_gimple_debug (use_stmt)) if (is_gimple_debug (use_stmt))
continue; continue;
else if (is_gimple_assign (use_stmt));
else if (gimple_code (use_stmt) == GIMPLE_COND else if (gimple_code (use_stmt) == GIMPLE_COND
|| gimple_code (use_stmt) == GIMPLE_PHI) || gimple_code (use_stmt) == GIMPLE_PHI)
FOR_EACH_IMM_USE_ON_STMT (use_p, iter) FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment