* [PATCH] SCCVN TLC
@ 2015-10-02 7:34 Richard Biener
0 siblings, 0 replies; 2+ messages in thread
From: Richard Biener @ 2015-10-02 7:34 UTC (permalink / raw)
To: gcc-patches
This removes some more dead code and refactors visit_use a bit.
Bootstrapped & tested on x86_64-unknown-linux-gnu, applied.
Richard.
2015-10-01 Richard Biener <rguenther@suse.de>
* tree-ssa-sccvn.c (has_VN_INFO): New function.
(free_scc_vn): Use it.
(visit_use): Remove dead code and refactor to use gassign
and use less indentation.
Index: gcc/tree-ssa-sccvn.c
===================================================================
--- gcc/tree-ssa-sccvn.c (revision 228320)
+++ gcc/tree-ssa-sccvn.c (working copy)
@@ -365,6 +365,16 @@ static vec<tree> sccstack;
static vec<vn_ssa_aux_t> vn_ssa_aux_table;
static struct obstack vn_ssa_aux_obstack;
+/* Return whether there is value numbering information for a given SSA name. */
+
+bool
+has_VN_INFO (tree name)
+{
+ if (SSA_NAME_VERSION (name) < vn_ssa_aux_table.length ())
+ return vn_ssa_aux_table[SSA_NAME_VERSION (name)] != NULL;
+ return false;
+}
+
/* Return the value numbering information for a given SSA name. */
vn_ssa_aux_t
@@ -3316,34 +3371,118 @@ visit_use (tree use)
/* Handle uninitialized uses. */
if (SSA_NAME_IS_DEFAULT_DEF (use))
changed = set_ssa_val_to (use, use);
- else
- {
- if (gimple_code (stmt) == GIMPLE_PHI)
- changed = visit_phi (stmt);
- else if (gimple_has_volatile_ops (stmt))
- changed = defs_to_varying (stmt);
- else if (is_gimple_assign (stmt))
- {
- enum tree_code code = gimple_assign_rhs_code (stmt);
- tree lhs = gimple_assign_lhs (stmt);
- tree rhs1 = gimple_assign_rhs1 (stmt);
- tree simplified;
-
- /* Shortcut for copies. Simplifying copies is pointless,
- since we copy the expression and value they represent. */
- if (code == SSA_NAME
- && TREE_CODE (lhs) == SSA_NAME)
+ else if (gimple_code (stmt) == GIMPLE_PHI)
+ changed = visit_phi (stmt);
+ else if (gimple_has_volatile_ops (stmt))
+ changed = defs_to_varying (stmt);
+ else if (gassign *ass = dyn_cast <gassign *> (stmt))
+ {
+ enum tree_code code = gimple_assign_rhs_code (ass);
+ tree lhs = gimple_assign_lhs (ass);
+ tree rhs1 = gimple_assign_rhs1 (ass);
+ tree simplified;
+
+ /* Shortcut for copies. Simplifying copies is pointless,
+ since we copy the expression and value they represent. */
+ if (code == SSA_NAME
+ && TREE_CODE (lhs) == SSA_NAME)
+ {
+ changed = visit_copy (lhs, rhs1);
+ goto done;
+ }
+ simplified = try_to_simplify (ass);
+ if (simplified)
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
{
- changed = visit_copy (lhs, rhs1);
- goto done;
+ fprintf (dump_file, "RHS ");
+ print_gimple_expr (dump_file, ass, 0, 0);
+ fprintf (dump_file, " simplified to ");
+ print_generic_expr (dump_file, simplified, 0);
+ fprintf (dump_file, "\n");
+ }
+ }
+ /* Setting value numbers to constants will occasionally
+ screw up phi congruence because constants are not
+ uniquely associated with a single ssa name that can be
+ looked up. */
+ if (simplified
+ && is_gimple_min_invariant (simplified)
+ && TREE_CODE (lhs) == SSA_NAME)
+ {
+ changed = set_ssa_val_to (lhs, simplified);
+ goto done;
+ }
+ else if (simplified
+ && TREE_CODE (simplified) == SSA_NAME
+ && TREE_CODE (lhs) == SSA_NAME)
+ {
+ changed = visit_copy (lhs, simplified);
+ goto done;
+ }
+
+ if ((TREE_CODE (lhs) == SSA_NAME
+ /* We can substitute SSA_NAMEs that are live over
+ abnormal edges with their constant value. */
+ && !(gimple_assign_copy_p (ass)
+ && is_gimple_min_invariant (rhs1))
+ && !(simplified
+ && is_gimple_min_invariant (simplified))
+ && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
+ /* Stores or copies from SSA_NAMEs that are live over
+ abnormal edges are a problem. */
+ || (code == SSA_NAME
+ && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)))
+ changed = defs_to_varying (ass);
+ else if (REFERENCE_CLASS_P (lhs)
+ || DECL_P (lhs))
+ changed = visit_reference_op_store (lhs, rhs1, ass);
+ else if (TREE_CODE (lhs) == SSA_NAME)
+ {
+ if ((gimple_assign_copy_p (ass)
+ && is_gimple_min_invariant (rhs1))
+ || (simplified
+ && is_gimple_min_invariant (simplified)))
+ {
+ if (simplified)
+ changed = set_ssa_val_to (lhs, simplified);
+ else
+ changed = set_ssa_val_to (lhs, rhs1);
+ }
+ else
+ {
+ /* Visit the original statement. */
+ switch (vn_get_stmt_kind (ass))
+ {
+ case VN_NARY:
+ changed = visit_nary_op (lhs, ass);
+ break;
+ case VN_REFERENCE:
+ changed = visit_reference_op_load (lhs, rhs1, ass);
+ break;
+ default:
+ changed = defs_to_varying (ass);
+ break;
+ }
}
- simplified = try_to_simplify (as_a <gassign *> (stmt));
+ }
+ else
+ changed = defs_to_varying (ass);
+ }
+ else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
+ {
+ tree lhs = gimple_call_lhs (call_stmt);
+ if (lhs && TREE_CODE (lhs) == SSA_NAME)
+ {
+ /* Try constant folding based on our current lattice. */
+ tree simplified = gimple_fold_stmt_to_constant_1 (call_stmt,
+ vn_valueize);
if (simplified)
{
if (dump_file && (dump_flags & TDF_DETAILS))
{
- fprintf (dump_file, "RHS ");
- print_gimple_expr (dump_file, stmt, 0, 0);
+ fprintf (dump_file, "call ");
+ print_gimple_expr (dump_file, call_stmt, 0, 0);
fprintf (dump_file, " simplified to ");
print_generic_expr (dump_file, simplified, 0);
fprintf (dump_file, "\n");
@@ -3354,168 +3493,57 @@ visit_use (tree use)
uniquely associated with a single ssa name that can be
looked up. */
if (simplified
- && is_gimple_min_invariant (simplified)
- && TREE_CODE (lhs) == SSA_NAME)
+ && is_gimple_min_invariant (simplified))
{
changed = set_ssa_val_to (lhs, simplified);
+ if (gimple_vdef (call_stmt))
+ changed |= set_ssa_val_to (gimple_vdef (call_stmt),
+ SSA_VAL (gimple_vuse (call_stmt)));
goto done;
}
else if (simplified
- && TREE_CODE (simplified) == SSA_NAME
- && TREE_CODE (lhs) == SSA_NAME)
+ && TREE_CODE (simplified) == SSA_NAME)
{
changed = visit_copy (lhs, simplified);
+ if (gimple_vdef (call_stmt))
+ changed |= set_ssa_val_to (gimple_vdef (call_stmt),
+ SSA_VAL (gimple_vuse (call_stmt)));
goto done;
}
-
- if ((TREE_CODE (lhs) == SSA_NAME
- /* We can substitute SSA_NAMEs that are live over
- abnormal edges with their constant value. */
- && !(gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (rhs1))
- && !(simplified
- && is_gimple_min_invariant (simplified))
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
- /* Stores or copies from SSA_NAMEs that are live over
- abnormal edges are a problem. */
- || (code == SSA_NAME
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)))
- changed = defs_to_varying (stmt);
- else if (REFERENCE_CLASS_P (lhs)
- || DECL_P (lhs))
- changed = visit_reference_op_store (lhs, rhs1, stmt);
- else if (TREE_CODE (lhs) == SSA_NAME)
- {
- if ((gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (rhs1))
- || (simplified
- && is_gimple_min_invariant (simplified)))
- {
- if (simplified)
- changed = set_ssa_val_to (lhs, simplified);
- else
- changed = set_ssa_val_to (lhs, rhs1);
- }
- else
- {
- /* First try to lookup the simplified expression. */
- if (simplified)
- {
- enum gimple_rhs_class rhs_class;
-
-
- rhs_class = get_gimple_rhs_class (TREE_CODE (simplified));
- if ((rhs_class == GIMPLE_UNARY_RHS
- || rhs_class == GIMPLE_BINARY_RHS
- || rhs_class == GIMPLE_TERNARY_RHS)
- && valid_gimple_rhs_p (simplified))
- {
- tree result = vn_nary_op_lookup (simplified, NULL);
- if (result)
- {
- changed = set_ssa_val_to (lhs, result);
- goto done;
- }
- }
- }
-
- /* Otherwise visit the original statement. */
- switch (vn_get_stmt_kind (stmt))
- {
- case VN_NARY:
- changed = visit_nary_op (lhs, stmt);
- break;
- case VN_REFERENCE:
- changed = visit_reference_op_load (lhs, rhs1, stmt);
- break;
- default:
- changed = defs_to_varying (stmt);
- break;
- }
- }
- }
- else
- changed = defs_to_varying (stmt);
- }
- else if (gcall *call_stmt = dyn_cast <gcall *> (stmt))
- {
- tree lhs = gimple_call_lhs (stmt);
- if (lhs && TREE_CODE (lhs) == SSA_NAME)
+ else if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
{
- /* Try constant folding based on our current lattice. */
- tree simplified = gimple_fold_stmt_to_constant_1 (stmt,
- vn_valueize);
- if (simplified)
- {
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "call ");
- print_gimple_expr (dump_file, stmt, 0, 0);
- fprintf (dump_file, " simplified to ");
- print_generic_expr (dump_file, simplified, 0);
- fprintf (dump_file, "\n");
- }
- }
- /* Setting value numbers to constants will occasionally
- screw up phi congruence because constants are not
- uniquely associated with a single ssa name that can be
- looked up. */
- if (simplified
- && is_gimple_min_invariant (simplified))
- {
- changed = set_ssa_val_to (lhs, simplified);
- if (gimple_vdef (stmt))
- changed |= set_ssa_val_to (gimple_vdef (stmt),
- SSA_VAL (gimple_vuse (stmt)));
- goto done;
- }
- else if (simplified
- && TREE_CODE (simplified) == SSA_NAME)
- {
- changed = visit_copy (lhs, simplified);
- if (gimple_vdef (stmt))
- changed |= set_ssa_val_to (gimple_vdef (stmt),
- SSA_VAL (gimple_vuse (stmt)));
- goto done;
- }
- else
- {
- if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
- {
- changed = defs_to_varying (stmt);
- goto done;
- }
- }
+ changed = defs_to_varying (call_stmt);
+ goto done;
}
-
- if (!gimple_call_internal_p (stmt)
- && (/* Calls to the same function with the same vuse
- and the same operands do not necessarily return the same
- value, unless they're pure or const. */
- gimple_call_flags (stmt) & (ECF_PURE | ECF_CONST)
- /* If calls have a vdef, subsequent calls won't have
- the same incoming vuse. So, if 2 calls with vdef have the
- same vuse, we know they're not subsequent.
- We can value number 2 calls to the same function with the
- same vuse and the same operands which are not subsequent
- the same, because there is no code in the program that can
- compare the 2 values... */
- || (gimple_vdef (stmt)
- /* ... unless the call returns a pointer which does
- not alias with anything else. In which case the
- information that the values are distinct are encoded
- in the IL. */
- && !(gimple_call_return_flags (call_stmt) & ERF_NOALIAS)
- /* Only perform the following when being called from PRE
- which embeds tail merging. */
- && default_vn_walk_kind == VN_WALK)))
- changed = visit_reference_op_call (lhs, call_stmt);
- else
- changed = defs_to_varying (stmt);
}
+
+ if (!gimple_call_internal_p (call_stmt)
+ && (/* Calls to the same function with the same vuse
+ and the same operands do not necessarily return the same
+ value, unless they're pure or const. */
+ gimple_call_flags (call_stmt) & (ECF_PURE | ECF_CONST)
+ /* If calls have a vdef, subsequent calls won't have
+ the same incoming vuse. So, if 2 calls with vdef have the
+ same vuse, we know they're not subsequent.
+ We can value number 2 calls to the same function with the
+ same vuse and the same operands which are not subsequent
+ the same, because there is no code in the program that can
+ compare the 2 values... */
+ || (gimple_vdef (call_stmt)
+ /* ... unless the call returns a pointer which does
+ not alias with anything else. In which case the
+ information that the values are distinct are encoded
+ in the IL. */
+ && !(gimple_call_return_flags (call_stmt) & ERF_NOALIAS)
+ /* Only perform the following when being called from PRE
+ which embeds tail merging. */
+ && default_vn_walk_kind == VN_WALK)))
+ changed = visit_reference_op_call (lhs, call_stmt);
else
- changed = defs_to_varying (stmt);
+ changed = defs_to_varying (call_stmt);
}
+ else
+ changed = defs_to_varying (stmt);
done:
return changed;
}
@@ -4001,8 +4029,7 @@ free_scc_vn (void)
{
tree name = ssa_name (i);
if (name
- && SSA_NAME_VERSION (name) < vn_ssa_aux_table.length ()
- && vn_ssa_aux_table[SSA_NAME_VERSION (name)]
+ && has_VN_INFO (name)
&& VN_INFO (name)->needs_insertion)
release_ssa_name (name);
}
^ permalink raw reply [flat|nested] 2+ messages in thread
* [PATCH] SCCVN TLC
@ 2011-09-06 10:28 Richard Guenther
0 siblings, 0 replies; 2+ messages in thread
From: Richard Guenther @ 2011-09-06 10:28 UTC (permalink / raw)
To: gcc-patches
Some cleanups before I touch this code.
Bootstrapped and tested on x86_64-unknown-linux-gnu, applied to trunk.
Richard.
2011-09-06 Richard Guenther <rguenther@suse.de>
* tree-ssa-sccvn.c (visit_use): CSE stmt pieces and simplify
matching.
Index: gcc/tree-ssa-sccvn.c
===================================================================
--- gcc/tree-ssa-sccvn.c (revision 178570)
+++ gcc/tree-ssa-sccvn.c (working copy)
@@ -3043,16 +3043,17 @@ visit_use (tree use)
changed = defs_to_varying (stmt);
else if (is_gimple_assign (stmt))
{
+ enum tree_code code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
+ tree rhs1 = gimple_assign_rhs1 (stmt);
tree simplified;
/* Shortcut for copies. Simplifying copies is pointless,
since we copy the expression and value they represent. */
- if (gimple_assign_copy_p (stmt)
- && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
+ if (code == SSA_NAME
&& TREE_CODE (lhs) == SSA_NAME)
{
- changed = visit_copy (lhs, gimple_assign_rhs1 (stmt));
+ changed = visit_copy (lhs, rhs1);
goto done;
}
simplified = try_to_simplify (stmt);
@@ -3119,24 +3120,22 @@ visit_use (tree use)
/* We can substitute SSA_NAMEs that are live over
abnormal edges with their constant value. */
&& !(gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
+ && is_gimple_min_invariant (rhs1))
&& !(simplified
&& is_gimple_min_invariant (simplified))
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
/* Stores or copies from SSA_NAMEs that are live over
abnormal edges are a problem. */
- || (gimple_assign_single_p (stmt)
- && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt))))
+ || (code == SSA_NAME
+ && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)))
changed = defs_to_varying (stmt);
- else if (REFERENCE_CLASS_P (lhs) || DECL_P (lhs))
- {
- changed = visit_reference_op_store (lhs, gimple_assign_rhs1 (stmt), stmt);
- }
+ else if (REFERENCE_CLASS_P (lhs)
+ || DECL_P (lhs))
+ changed = visit_reference_op_store (lhs, rhs1, stmt);
else if (TREE_CODE (lhs) == SSA_NAME)
{
if ((gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
+ && is_gimple_min_invariant (rhs1))
|| (simplified
&& is_gimple_min_invariant (simplified)))
{
@@ -3144,11 +3143,11 @@ visit_use (tree use)
if (simplified)
changed = set_ssa_val_to (lhs, simplified);
else
- changed = set_ssa_val_to (lhs, gimple_assign_rhs1 (stmt));
+ changed = set_ssa_val_to (lhs, rhs1);
}
else
{
- switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
+ switch (get_gimple_rhs_class (code))
{
case GIMPLE_UNARY_RHS:
case GIMPLE_BINARY_RHS:
@@ -3156,25 +3155,24 @@ visit_use (tree use)
changed = visit_nary_op (lhs, stmt);
break;
case GIMPLE_SINGLE_RHS:
- switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
+ switch (TREE_CODE_CLASS (code))
{
case tcc_reference:
/* VOP-less references can go through unary case. */
- if ((gimple_assign_rhs_code (stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
- || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
- && TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (stmt), 0)) == SSA_NAME)
+ if ((code == REALPART_EXPR
+ || code == IMAGPART_EXPR
+ || code == VIEW_CONVERT_EXPR)
+ && TREE_CODE (TREE_OPERAND (rhs1, 0)) == SSA_NAME)
{
changed = visit_nary_op (lhs, stmt);
break;
}
/* Fallthrough. */
case tcc_declaration:
- changed = visit_reference_op_load
- (lhs, gimple_assign_rhs1 (stmt), stmt);
+ changed = visit_reference_op_load (lhs, rhs1, stmt);
break;
case tcc_expression:
- if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
+ if (code == ADDR_EXPR)
{
changed = visit_nary_op (lhs, stmt);
break;
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2015-10-02 7:34 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-10-02 7:34 [PATCH] SCCVN TLC Richard Biener
-- strict thread matches above, loose matches on Subject: below --
2011-09-06 10:28 Richard Guenther
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).