This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [tuples][patch] Convert pass_ccp and pass_store_ccp to tuples
- From: Diego Novillo <dnovillo at google dot com>
- To: Bill Maddox <maddox at google dot com>
- Cc: gcc-patches <gcc-patches at gcc dot gnu dot org>
- Date: Tue, 04 Mar 2008 09:43:51 -0500
- Subject: Re: [tuples][patch] Convert pass_ccp and pass_store_ccp to tuples
- References: <8a0e66f0803032050s54785ec4ib4aea1d509e43da5@mail.gmail.com>
On 3/3/08 11:50 PM, Bill Maddox wrote:
Testing revealed a handful of failures that appear to be pass-order
dependencies, or, in one case, a pre-existing issue with mainline.
There is a net increase of 79 passing tests on the C tests and no
regressions elsewhere.
Is this the -fno-tree-dce problem we chatted about earlier? That bug is
also present in mainline, could you file a bugzilla PR for it?
+/* FIXME tuples. This function appears to be called only for
+ assignments, calls, conditionalss, and switches, due to the
s/conditionalss/conditionals/
+ logic in visit_stmt, carried over from the pre-tuples code.
+ The function purports to handle return statements, but they
+ should never bee seen, and produce no propagatable value. */
s/bee/be/
+ /* FIXME tuples. Why is this case handled at all? */
+ if (gimple_code (stmt) == GIMPLE_RETURN
+ && gimple_return_retval (stmt) != NULL_TREE
+ && is_gimple_min_invariant (gimple_return_retval (stmt)))
return CONSTANT;
Let's remove this code and assert that likely_value is not being called
with anything other than assignments, calls and conditionals.
@@ -888,134 +906,192 @@ ccp_visit_phi_node (tree phi)
operands are constants.
If simplification is possible, return the simplified RHS,
- otherwise return the original RHS. */
+ otherwise return the original LHS or NULL_TREE. */
You mean RHS here?
+/* FIXME tuples. It would be preferable to consistently
+ return either NULL_TREE or the original RHS. Currently,
+ we attempt to follow the pre-tuples behavior. */
Just returning NULL when folding isn't possible is fine. Just make sure
the callers handle it.
+ /* Substitute operands with their values and try to fold. */
+ replace_uses_in (stmt, NULL, const_val);
+ /* FIXME tuples. */
+#if 0
+ retval = fold_call_expr (rhs, false);
+#else
+ retval = NULL_TREE;
This should call fold_gimple_call, but that is a destructive folder, so
we need to figure out something different here. For now, let's just
remove this handler, since as you note below, it is never invoked.
+ /* FIXME tuples. There is no original RHS to return here. */
+ return NULL_TREE;
That's fine. Returning NULL_TREE is OK, as long as we fix all the
callers to handle this. No need to have a FIXME note.
+ /* FIXME tuples. This is the only place that we call ccp_fold.
+ Since likely_value never returns CONSTANT for function calls,
+ the attempt to handle them in ccp_fold is inoperative. */
if (likelyvalue == CONSTANT)
simplified = ccp_fold (stmt);
Ah, yes. Let's do this: in ccp_fold assert that we are not given a
GIMPLE_CALL. There is a note in likely_value saying that for some call
sites we may want to return CONSTANT. When that spot is fixed, the
assert in ccp_fold() will trigger.
+ /* FIXME tuples. It appears that we should be able to optimize
+ computed GOTOs here as well, but the the original pre-tuples
+ code did not do so, so we defer. */
No 'FIXME tuples' here, please. If it's an existing limitation, use
'FIXME', but we are using 'FIXME tuples' to mark spots that need to be
fixed before merging into mainline.
+/* FIXME tuples. Some builtins expand into inline code that may
+ not be valid in GIMPLE. Callers must take care. */
This was true before tuples, so no 'FIXME tuples' here.
@@ -512,6 +512,9 @@ ssa_prop_init (void)
for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
gimple_set_plf (gsi_stmt (si), STMT_IN_SSA_EDGE_WORKLIST, false);
+
+ for (si = gsi_start (phi_nodes (bb)); !gsi_end_p (si); gsi_next (&si))
+ gimple_set_plf (gsi_stmt (si), STMT_IN_SSA_EDGE_WORKLIST, false);
This is not needed. PHI nodes are always simulated.
STMT_IN_SSA_EDGE_WORKLIST should not affect PHI nodes. If this fixed
something, it probably papered over the real bug.
rhs = gimple_assign_rhs1 (stmt);
+ STRIP_NOPS (rhs);
+
Not needed. An operand never has NOPs.
+tree
+get_lhs (gimple stmt)
+{
+ enum tree_code code = gimple_code (stmt);
+
+ if (code == GIMPLE_ASSIGN)
+ return gimple_assign_lhs (stmt);
+ else if (code == GIMPLE_CALL)
+ return gimple_call_lhs (stmt);
+ else
+ gcc_unreachable();
+}
+
+
+/* Set the LHS of a statement that performs an assignment,
+ either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
+
+void
+set_lhs (gimple stmt, tree lhs)
+{
+ enum tree_code code = gimple_code (stmt);
+
+ if (code == GIMPLE_ASSIGN)
+ return gimple_assign_set_lhs (stmt, lhs);
+ else if (code == GIMPLE_CALL)
+ return gimple_call_set_lhs (stmt, lhs);
+ else
+ gcc_unreachable();
+}
+
These two may be needed in other optimizers. Move them to gimple.c and
rename gimple_get_lhs(), gimple_set_lhs(). Also, I think we probably
don't want to assert for things different than GIMPLE_ASSIGN and
GIMPLE_CALL.
+/* FIXME tuples. The charter of this function is unclear. It was
+ introduced to replace occurrences of unshare_expr in cases where
+ a statement is copied temporarily in order to present a "before
+ and after" diagnostic, e.g., showing folding in substitute_and_fold.
+ In that case, uses occuring in the saved statement were linked from
+ definitions elsewhere, confusing code that expected no such uses to
+ exist. It might be preferable to rewrite such diagnostics to simply
+ dump the "before" diagnostic to a string, rather than retaining a
+ statement for later processing. */
Agreed. This can be done in a later patch.
Thanks. Diego.