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

cfgloop.c (flow_loops_find): Use the information of the depth first search order of the CFG correctly when... 

* cfgloop.c (flow_loops_find): Use the information of the depth
        first search order of the CFG correctly when finding natural loops.

From-SVN: r48227
This commit is contained in:
Josef Zlomek 2001-12-21 02:50:10 +01:00 committed by Richard Henderson
parent f350566bf4
commit b09d108b48
2 changed files with 18 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gcc/ChangeLog
View File

@ -1,3 +1,8 @@
2001-12-20 Josef Zlomek <zlomek@matfyz.cz>
* cfgloop.c (flow_loops_find): Use the information of the depth
first search order of the CFG correctly when finding natural loops.
2001-12-20 Richard Henderson <rth@redhat.com>
* config/alpha/alpha.md (prologue_mcount): Update for explicit relocs.

26
gcc/cfgloop.c
View File

@ -737,26 +737,26 @@ flow_loops_find (loops, flags)
/* Find and record information about all the natural loops
in the CFG. */
num_loops = 0;
for (b = 0; b < n_basic_blocks; b++)
for (b = n_basic_blocks - 1; b >= 0; b--)
{
basic_block header;
basic_block latch;
/* Search the nodes of the CFG in reverse completion order
so that we can find outer loops first. */
header = BASIC_BLOCK (rc_order[b]);
latch = BASIC_BLOCK (rc_order[b]);
/* Look for all the possible latch blocks for this header. */
for (e = header->pred; e; e = e->pred_next)
/* Look for all the possible headers for this latch block. */
for (e = latch->succ; e; e = e->succ_next)
{
basic_block latch = e->src;
basic_block header = e->dest;
/* Look for back edges where a predecessor is dominated
by this block. A natural loop has a single entry
node (header) that dominates all the nodes in the
loop. It also has single back edge to the header
from a latch node. Note that multiple natural loops
may share the same header. */
if (latch != ENTRY_BLOCK_PTR
/* Look for forward edges where this block is dominated by
a successor of this block. A natural loop has a single
entry node (header) that dominates all the nodes in the
loop. It also has single back edge to the header from a
latch node. Note that multiple natural loops may share
the same header. */
if (header != EXIT_BLOCK_PTR
&& TEST_BIT (dom[latch->index], header->index))
{
struct loop *loop;