On Wed, 2013-11-20 at 11:07 +0100, Jan-Benedict Glaw wrote:
> On Wed, 2013-11-20 10:08:45 +0100, Steven Bosscher <stevenb....@gmail.com>
> wrote:
> [...]
> > I wonder if there are any more cases like this missed... Could you
> > please check that? Something like:
> >
> > egrep -w "ENTRY_BLOCK_PTR|EXIT_BLOCK_PTR" gcc/*.[ch] gcc/config/*.[ch]
> > gcc/config/*/*.{c,h,md}
>
> No more uses, but 21 comment lines contain references to the macros.
Sorry about the mips breakage, and thanks for fixing it.
I went through the comment lines, rewording the ones where the meaning
was obvious to me. Attached is a patch that does so; successfully
compiled stage1; OK for trunk? (these are just changes to comments, so
not sure a full bootstrap is necessary).
There are three places the patch doesn't touch:
(A) cfgbuild.c (make_edges) has this comment:
/* By nature of the way these get numbered, ENTRY_BLOCK_PTR->next_bb block
is always the entry. */
where the meaning wasn't immediately clear to me - what is the second
"entry" here? (I haven't looked in detail at the algorithm).
FWIW the wording of this comment came from r53804:
2002-05-23 Zdenek Dvorak <rakd...@atrey.karlin.mff.cuni.cz>
* bb-reorder.c [...]: Use FOR_EACH_BB macros to iterate over
basic block chain.
[...]
* cfgbuild.c [...]: Likewise.
which made this change to the comment:
- /* By nature of the way these get numbered, block 0 is always the
entry. */
+ /* By nature of the way these get numbered, ENTRY_BLOCK_PTR->next_bb
block
+ is always the entry. */
(B) graphite-scop-detection.c (scopdet_basic_block_info) has:
/* XXX: ENTRY_BLOCK_PTR could be optimized in later steps. */
where the meaning isn't clear to me - whether this is a note about a
possible further optimization, or a warning that the entry could be
changed.
(C) tree-cfg.c (move_sese_region_to_fn): line 6899 has:
FIXME, this is silly. The CFG ought to become a parameter to
these helpers. */
where cfun is perhaps being unecessarily manipulated, and perhaps we
could actually gain a speedup from the macro removal work; if so, this
feels like a followup patch.
Comment-fixing patch follows.
commit f9ac8591f2ef893f489a0cec812c3198d8eaea5c
Author: David Malcolm <dmalc...@redhat.com>
Date: Mon Nov 18 21:16:04 2013 -0500
Reword comments that mention ENTRY_BLOCK_PTR and EXIT_BLOCK_PTR macros
gcc/
* cfg.c (dump_edge_info): Remove redundant comment.
* cfgcleanup.c (outgoing_edges_match): Reword reference to
EXIT_BLOCK_PTR in comment.
(try_optimize_cfg): Likewise.
* cfgrtl.c (last_bb_in_partition): Likewise.
* cgraph.c (cgraph_node_cannot_return): Likewise.
* function.c (thread_prologue_and_epilogue_insns): Likewise.
* graphite-scop-detection.c (scopdet_basic_block_info): Likewise.
* ipa-split.c (consider_split): Likewise.
* profile.c (find_spanning_tree): Likewise.
* sched-int.h (common_sched_info_def.add_block): Likewise.
* dominance.c (calc_dfs_tree_nonrec): Reword references in
comments to now removed ENTRY_BLOCK_PTR and EXIT_BLOCK_PTR macros.
* tree-cfgcleanup.c (cleanup_control_flow_bb): Reword references
in comments to now removed ENTRY_BLOCK_PTR macro.
(tree_forwarder_block_p): Reword reference in comment to
EXIT_BLOCK_PTR.
* tree-inline.c (copy_cfg_body): Reword references in comments to
now removed ENTRY_BLOCK_PTR macro.
* tree-ssa-propagate.c (ssa_prop_init): Likewise.
* tree-scalar-evolution.h ( block_before_loop): Likewise. Add
a comma to the comment to clarify the meaning.
diff --git a/gcc/cfg.c b/gcc/cfg.c
index e35eee9..6bceca5 100644
--- a/gcc/cfg.c
+++ b/gcc/cfg.c
@@ -473,8 +473,6 @@ dump_edge_info (FILE *file, edge e, int flags, int do_succ)
&& (flags & TDF_SLIM) == 0)
do_details = true;
- /* ENTRY_BLOCK_PTR/EXIT_BLOCK_PTR depend on cfun.
- Compare against ENTRY_BLOCK/EXIT_BLOCK to avoid that dependency. */
if (side->index == ENTRY_BLOCK)
fputs (" ENTRY", file);
else if (side->index == EXIT_BLOCK)
diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index 9c12610..dbaee96 100644
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -1535,7 +1535,7 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
edge e1, e2;
edge_iterator ei;
- /* If we performed shrink-wrapping, edges to the EXIT_BLOCK_PTR can
+ /* If we performed shrink-wrapping, edges to the exit block can
only be distinguished for JUMP_INSNs. The two paths may differ in
whether they went through the prologue. Sibcalls are fine, we know
that we either didn't need or inserted an epilogue before them. */
@@ -2684,7 +2684,7 @@ try_optimize_cfg (int mode)
}
delete_basic_block (b);
changed = true;
- /* Avoid trying to remove ENTRY_BLOCK_PTR. */
+ /* Avoid trying to remove the exit block. */
b = (c == ENTRY_BLOCK_PTR_FOR_FN (cfun) ? c->next_bb : c);
continue;
}
diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index 7ad3872..63f44af 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -1795,7 +1795,7 @@ last_bb_in_partition (basic_block start_bb)
if (BB_PARTITION (start_bb) != BB_PARTITION (bb->next_bb))
return bb;
}
- /* Return bb before EXIT_BLOCK_PTR. */
+ /* Return bb before the exit block. */
return bb->prev_bb;
}
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 624d492..009a165 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -2334,7 +2334,7 @@ cgraph_node_cannot_return (struct cgraph_node *node)
and thus it is safe to ignore its side effects for IPA analysis
when computing side effects of the caller.
FIXME: We could actually mark all edges that have no reaching
- patch to EXIT_BLOCK_PTR or throw to get better results. */
+ patch to the exit block or throw to get better results. */
bool
cgraph_edge_cannot_lead_to_return (struct cgraph_edge *e)
{
diff --git a/gcc/dominance.c b/gcc/dominance.c
index 3d88c0d..5ece3f6 100644
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -227,7 +227,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb, bool reverse)
edge_iterator *stack;
edge_iterator ei, einext;
int sp;
- /* Start block (ENTRY_BLOCK_PTR for forward problem, EXIT_BLOCK for backward
+ /* Start block (the entry block for forward problem, exit block for backward
problem). */
basic_block en_block;
/* Ending block. */
diff --git a/gcc/function.c b/gcc/function.c
index fde4a8e..5b33c46 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -6349,7 +6349,7 @@ thread_prologue_and_epilogue_insns (void)
{
unsigned i, last;
- /* convert_jumps_to_returns may add to EXIT_BLOCK_PTR->preds
+ /* convert_jumps_to_returns may add to preds of the exit block
(but won't remove). Stop at end of current preds. */
last = EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
for (i = 0; i < last; i++)
diff --git a/gcc/graphite-scop-detection.c b/gcc/graphite-scop-detection.c
index 0cfb5a5..15c4c0f 100644
--- a/gcc/graphite-scop-detection.c
+++ b/gcc/graphite-scop-detection.c
@@ -518,7 +518,7 @@ scopdet_basic_block_info (basic_block bb, loop_p outermost_loop,
result.next = exit_e->dest;
/* If we do not dominate result.next, remove it. It's either
- the EXIT_BLOCK_PTR, or another bb dominates it and will
+ the exit block, or another bb dominates it and will
call the scop detection for this bb. */
if (!dominated_by_p (CDI_DOMINATORS, result.next, bb))
result.next = NULL;
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index d7d6b8f..2e8a062 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -635,7 +635,7 @@ consider_split (struct split_point *current, bitmap non_ssa_vars,
<retval> = tmp_var;
return <retval>
but return_bb can not be more complex than this.
- If nothing is found, return EXIT_BLOCK_PTR.
+ If nothing is found, return the exit block.
When there are multiple RETURN statement, chose one with return value,
since that one is more likely shared by multiple code paths.
diff --git a/gcc/profile.c b/gcc/profile.c
index 85671b3..1d0e78a 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -1392,7 +1392,7 @@ find_spanning_tree (struct edge_list *el)
union_groups (EXIT_BLOCK_PTR_FOR_FN (cfun), ENTRY_BLOCK_PTR_FOR_FN (cfun));
/* First add all abnormal edges to the tree unless they form a cycle. Also
- add all edges to EXIT_BLOCK_PTR to avoid inserting profiling code behind
+ add all edges to the exit block to avoid inserting profiling code behind
setting return value from function. */
for (i = 0; i < num_edges; i++)
{
diff --git a/gcc/sched-int.h b/gcc/sched-int.h
index 070404c..84b5cb5 100644
--- a/gcc/sched-int.h
+++ b/gcc/sched-int.h
@@ -70,7 +70,7 @@ struct common_sched_info_def
/* Called to notify frontend, that new basic block is being added.
The first parameter - new basic block.
The second parameter - block, after which new basic block is being added,
- or EXIT_BLOCK_PTR, if recovery block is being added,
+ or the exit block, if recovery block is being added,
or NULL, if standalone block is being added. */
void (*add_block) (basic_block, basic_block);
diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index 4e5adc2..5ae70ab 100644
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -237,7 +237,7 @@ cleanup_control_flow_bb (basic_block bb)
the start of the successor block.
As a precondition, we require that BB be not equal to
- ENTRY_BLOCK_PTR. */
+ the entry block. */
static bool
tree_forwarder_block_p (basic_block bb, bool phi_wanted)
@@ -250,7 +250,7 @@ tree_forwarder_block_p (basic_block bb, bool phi_wanted)
/* If PHI_WANTED is false, BB must not have any PHI nodes.
Otherwise, BB must have PHI nodes. */
|| gimple_seq_empty_p (phi_nodes (bb)) == phi_wanted
- /* BB may not be a predecessor of EXIT_BLOCK_PTR. */
+ /* BB may not be a predecessor of the exit block. */
|| single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun)
/* Nor should this be an infinite loop. */
|| single_succ (bb) == bb
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 25705a9..e9ddb16 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -2433,9 +2433,10 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency_scale,
/* Register specific tree functions. */
gimple_register_cfg_hooks ();
- /* If we are inlining just region of the function, make sure to connect new entry
- to ENTRY_BLOCK_PTR. Since new entry can be part of loop, we must compute
- frequency and probability of ENTRY_BLOCK_PTR based on the frequencies and
+ /* If we are inlining just region of the function, make sure to connect
+ new entry to ENTRY_BLOCK_PTR_FOR_FN (cfun). Since new entry can be
+ part of loop, we must compute frequency and probability of
+ ENTRY_BLOCK_PTR_FOR_FN (cfun) based on the frequencies and
probabilities of edges incoming from nonduplicated region. */
if (new_entry)
{
diff --git a/gcc/tree-scalar-evolution.h b/gcc/tree-scalar-evolution.h
index 8846fbe..fc87251 100644
--- a/gcc/tree-scalar-evolution.h
+++ b/gcc/tree-scalar-evolution.h
@@ -40,8 +40,8 @@ extern bool simple_iv (struct loop *, struct loop *, tree, struct affine_iv_d *,
bool);
extern tree compute_overall_effect_of_inner_loop (struct loop *, tree);
-/* Returns the basic block preceding LOOP or ENTRY_BLOCK_PTR when the
- loop is function's body. */
+/* Returns the basic block preceding LOOP, or the CFG entry block when
+ the loop is function's body. */
static inline basic_block
block_before_loop (loop_p loop)
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index b9db34c5..b45ff47 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -503,7 +503,7 @@ ssa_prop_init (void)
cfg_blocks.safe_grow_cleared (20);
/* Initially assume that every edge in the CFG is not executable.
- (including the edges coming out of ENTRY_BLOCK_PTR). */
+ (including the edges coming out of the entry block). */
FOR_ALL_BB (bb)
{
gimple_stmt_iterator si;
