/* Natural loop discovery code for GNU compiler.
|
/* Natural loop discovery code for GNU compiler.
|
Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
|
Copyright (C) 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "obstack.h"
|
#include "obstack.h"
|
#include "function.h"
|
#include "function.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "cfgloop.h"
|
#include "cfgloop.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
#include "output.h"
|
#include "output.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
|
|
static void flow_loops_cfg_dump (FILE *);
|
static void flow_loops_cfg_dump (FILE *);
|
|
|
/* Dump loop related CFG information. */
|
/* Dump loop related CFG information. */
|
|
|
static void
|
static void
|
flow_loops_cfg_dump (FILE *file)
|
flow_loops_cfg_dump (FILE *file)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
|
|
if (!file)
|
if (!file)
|
return;
|
return;
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
edge succ;
|
edge succ;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
fprintf (file, ";; %d succs { ", bb->index);
|
fprintf (file, ";; %d succs { ", bb->index);
|
FOR_EACH_EDGE (succ, ei, bb->succs)
|
FOR_EACH_EDGE (succ, ei, bb->succs)
|
fprintf (file, "%d ", succ->dest->index);
|
fprintf (file, "%d ", succ->dest->index);
|
fprintf (file, "}\n");
|
fprintf (file, "}\n");
|
}
|
}
|
}
|
}
|
|
|
/* Return nonzero if the nodes of LOOP are a subset of OUTER. */
|
/* Return nonzero if the nodes of LOOP are a subset of OUTER. */
|
|
|
bool
|
bool
|
flow_loop_nested_p (const struct loop *outer, const struct loop *loop)
|
flow_loop_nested_p (const struct loop *outer, const struct loop *loop)
|
{
|
{
|
unsigned odepth = loop_depth (outer);
|
unsigned odepth = loop_depth (outer);
|
|
|
return (loop_depth (loop) > odepth
|
return (loop_depth (loop) > odepth
|
&& VEC_index (loop_p, loop->superloops, odepth) == outer);
|
&& VEC_index (loop_p, loop->superloops, odepth) == outer);
|
}
|
}
|
|
|
/* Returns the loop such that LOOP is nested DEPTH (indexed from zero)
|
/* Returns the loop such that LOOP is nested DEPTH (indexed from zero)
|
loops within LOOP. */
|
loops within LOOP. */
|
|
|
struct loop *
|
struct loop *
|
superloop_at_depth (struct loop *loop, unsigned depth)
|
superloop_at_depth (struct loop *loop, unsigned depth)
|
{
|
{
|
unsigned ldepth = loop_depth (loop);
|
unsigned ldepth = loop_depth (loop);
|
|
|
gcc_assert (depth <= ldepth);
|
gcc_assert (depth <= ldepth);
|
|
|
if (depth == ldepth)
|
if (depth == ldepth)
|
return loop;
|
return loop;
|
|
|
return VEC_index (loop_p, loop->superloops, depth);
|
return VEC_index (loop_p, loop->superloops, depth);
|
}
|
}
|
|
|
/* Returns the list of the latch edges of LOOP. */
|
/* Returns the list of the latch edges of LOOP. */
|
|
|
static VEC (edge, heap) *
|
static VEC (edge, heap) *
|
get_loop_latch_edges (const struct loop *loop)
|
get_loop_latch_edges (const struct loop *loop)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
VEC (edge, heap) *ret = NULL;
|
VEC (edge, heap) *ret = NULL;
|
|
|
FOR_EACH_EDGE (e, ei, loop->header->preds)
|
FOR_EACH_EDGE (e, ei, loop->header->preds)
|
{
|
{
|
if (dominated_by_p (CDI_DOMINATORS, e->src, loop->header))
|
if (dominated_by_p (CDI_DOMINATORS, e->src, loop->header))
|
VEC_safe_push (edge, heap, ret, e);
|
VEC_safe_push (edge, heap, ret, e);
|
}
|
}
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Dump the loop information specified by LOOP to the stream FILE
|
/* Dump the loop information specified by LOOP to the stream FILE
|
using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
|
using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
|
|
|
void
|
void
|
flow_loop_dump (const struct loop *loop, FILE *file,
|
flow_loop_dump (const struct loop *loop, FILE *file,
|
void (*loop_dump_aux) (const struct loop *, FILE *, int),
|
void (*loop_dump_aux) (const struct loop *, FILE *, int),
|
int verbose)
|
int verbose)
|
{
|
{
|
basic_block *bbs;
|
basic_block *bbs;
|
unsigned i;
|
unsigned i;
|
VEC (edge, heap) *latches;
|
VEC (edge, heap) *latches;
|
edge e;
|
edge e;
|
|
|
if (! loop || ! loop->header)
|
if (! loop || ! loop->header)
|
return;
|
return;
|
|
|
fprintf (file, ";;\n;; Loop %d\n", loop->num);
|
fprintf (file, ";;\n;; Loop %d\n", loop->num);
|
|
|
fprintf (file, ";; header %d, ", loop->header->index);
|
fprintf (file, ";; header %d, ", loop->header->index);
|
if (loop->latch)
|
if (loop->latch)
|
fprintf (file, "latch %d\n", loop->latch->index);
|
fprintf (file, "latch %d\n", loop->latch->index);
|
else
|
else
|
{
|
{
|
fprintf (file, "multiple latches:");
|
fprintf (file, "multiple latches:");
|
latches = get_loop_latch_edges (loop);
|
latches = get_loop_latch_edges (loop);
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
fprintf (file, " %d", e->src->index);
|
fprintf (file, " %d", e->src->index);
|
VEC_free (edge, heap, latches);
|
VEC_free (edge, heap, latches);
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
}
|
}
|
|
|
fprintf (file, ";; depth %d, outer %ld\n",
|
fprintf (file, ";; depth %d, outer %ld\n",
|
loop_depth (loop), (long) (loop_outer (loop)
|
loop_depth (loop), (long) (loop_outer (loop)
|
? loop_outer (loop)->num : -1));
|
? loop_outer (loop)->num : -1));
|
|
|
fprintf (file, ";; nodes:");
|
fprintf (file, ";; nodes:");
|
bbs = get_loop_body (loop);
|
bbs = get_loop_body (loop);
|
for (i = 0; i < loop->num_nodes; i++)
|
for (i = 0; i < loop->num_nodes; i++)
|
fprintf (file, " %d", bbs[i]->index);
|
fprintf (file, " %d", bbs[i]->index);
|
free (bbs);
|
free (bbs);
|
fprintf (file, "\n");
|
fprintf (file, "\n");
|
|
|
if (loop_dump_aux)
|
if (loop_dump_aux)
|
loop_dump_aux (loop, file, verbose);
|
loop_dump_aux (loop, file, verbose);
|
}
|
}
|
|
|
/* Dump the loop information about loops to the stream FILE,
|
/* Dump the loop information about loops to the stream FILE,
|
using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
|
using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
|
|
|
void
|
void
|
flow_loops_dump (FILE *file, void (*loop_dump_aux) (const struct loop *, FILE *, int), int verbose)
|
flow_loops_dump (FILE *file, void (*loop_dump_aux) (const struct loop *, FILE *, int), int verbose)
|
{
|
{
|
loop_iterator li;
|
loop_iterator li;
|
struct loop *loop;
|
struct loop *loop;
|
|
|
if (!current_loops || ! file)
|
if (!current_loops || ! file)
|
return;
|
return;
|
|
|
fprintf (file, ";; %d loops found\n", number_of_loops ());
|
fprintf (file, ";; %d loops found\n", number_of_loops ());
|
|
|
FOR_EACH_LOOP (li, loop, LI_INCLUDE_ROOT)
|
FOR_EACH_LOOP (li, loop, LI_INCLUDE_ROOT)
|
{
|
{
|
flow_loop_dump (loop, file, loop_dump_aux, verbose);
|
flow_loop_dump (loop, file, loop_dump_aux, verbose);
|
}
|
}
|
|
|
if (verbose)
|
if (verbose)
|
flow_loops_cfg_dump (file);
|
flow_loops_cfg_dump (file);
|
}
|
}
|
|
|
/* Free data allocated for LOOP. */
|
/* Free data allocated for LOOP. */
|
|
|
void
|
void
|
flow_loop_free (struct loop *loop)
|
flow_loop_free (struct loop *loop)
|
{
|
{
|
struct loop_exit *exit, *next;
|
struct loop_exit *exit, *next;
|
|
|
VEC_free (loop_p, gc, loop->superloops);
|
VEC_free (loop_p, gc, loop->superloops);
|
|
|
/* Break the list of the loop exit records. They will be freed when the
|
/* Break the list of the loop exit records. They will be freed when the
|
corresponding edge is rescanned or removed, and this avoids
|
corresponding edge is rescanned or removed, and this avoids
|
accessing the (already released) head of the list stored in the
|
accessing the (already released) head of the list stored in the
|
loop structure. */
|
loop structure. */
|
for (exit = loop->exits->next; exit != loop->exits; exit = next)
|
for (exit = loop->exits->next; exit != loop->exits; exit = next)
|
{
|
{
|
next = exit->next;
|
next = exit->next;
|
exit->next = exit;
|
exit->next = exit;
|
exit->prev = exit;
|
exit->prev = exit;
|
}
|
}
|
|
|
ggc_free (loop->exits);
|
ggc_free (loop->exits);
|
ggc_free (loop);
|
ggc_free (loop);
|
}
|
}
|
|
|
/* Free all the memory allocated for LOOPS. */
|
/* Free all the memory allocated for LOOPS. */
|
|
|
void
|
void
|
flow_loops_free (struct loops *loops)
|
flow_loops_free (struct loops *loops)
|
{
|
{
|
if (loops->larray)
|
if (loops->larray)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
loop_p loop;
|
loop_p loop;
|
|
|
/* Free the loop descriptors. */
|
/* Free the loop descriptors. */
|
for (i = 0; VEC_iterate (loop_p, loops->larray, i, loop); i++)
|
for (i = 0; VEC_iterate (loop_p, loops->larray, i, loop); i++)
|
{
|
{
|
if (!loop)
|
if (!loop)
|
continue;
|
continue;
|
|
|
flow_loop_free (loop);
|
flow_loop_free (loop);
|
}
|
}
|
|
|
VEC_free (loop_p, gc, loops->larray);
|
VEC_free (loop_p, gc, loops->larray);
|
}
|
}
|
}
|
}
|
|
|
/* Find the nodes contained within the LOOP with header HEADER.
|
/* Find the nodes contained within the LOOP with header HEADER.
|
Return the number of nodes within the loop. */
|
Return the number of nodes within the loop. */
|
|
|
int
|
int
|
flow_loop_nodes_find (basic_block header, struct loop *loop)
|
flow_loop_nodes_find (basic_block header, struct loop *loop)
|
{
|
{
|
VEC (basic_block, heap) *stack = NULL;
|
VEC (basic_block, heap) *stack = NULL;
|
int num_nodes = 1;
|
int num_nodes = 1;
|
edge latch;
|
edge latch;
|
edge_iterator latch_ei;
|
edge_iterator latch_ei;
|
unsigned depth = loop_depth (loop);
|
unsigned depth = loop_depth (loop);
|
|
|
header->loop_father = loop;
|
header->loop_father = loop;
|
header->loop_depth = depth;
|
header->loop_depth = depth;
|
|
|
FOR_EACH_EDGE (latch, latch_ei, loop->header->preds)
|
FOR_EACH_EDGE (latch, latch_ei, loop->header->preds)
|
{
|
{
|
if (latch->src->loop_father == loop
|
if (latch->src->loop_father == loop
|
|| !dominated_by_p (CDI_DOMINATORS, latch->src, loop->header))
|
|| !dominated_by_p (CDI_DOMINATORS, latch->src, loop->header))
|
continue;
|
continue;
|
|
|
num_nodes++;
|
num_nodes++;
|
VEC_safe_push (basic_block, heap, stack, latch->src);
|
VEC_safe_push (basic_block, heap, stack, latch->src);
|
latch->src->loop_father = loop;
|
latch->src->loop_father = loop;
|
latch->src->loop_depth = depth;
|
latch->src->loop_depth = depth;
|
|
|
while (!VEC_empty (basic_block, stack))
|
while (!VEC_empty (basic_block, stack))
|
{
|
{
|
basic_block node;
|
basic_block node;
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
node = VEC_pop (basic_block, stack);
|
node = VEC_pop (basic_block, stack);
|
|
|
FOR_EACH_EDGE (e, ei, node->preds)
|
FOR_EACH_EDGE (e, ei, node->preds)
|
{
|
{
|
basic_block ancestor = e->src;
|
basic_block ancestor = e->src;
|
|
|
if (ancestor->loop_father != loop)
|
if (ancestor->loop_father != loop)
|
{
|
{
|
ancestor->loop_father = loop;
|
ancestor->loop_father = loop;
|
ancestor->loop_depth = depth;
|
ancestor->loop_depth = depth;
|
num_nodes++;
|
num_nodes++;
|
VEC_safe_push (basic_block, heap, stack, ancestor);
|
VEC_safe_push (basic_block, heap, stack, ancestor);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
VEC_free (basic_block, heap, stack);
|
VEC_free (basic_block, heap, stack);
|
|
|
return num_nodes;
|
return num_nodes;
|
}
|
}
|
|
|
/* Records the vector of superloops of the loop LOOP, whose immediate
|
/* Records the vector of superloops of the loop LOOP, whose immediate
|
superloop is FATHER. */
|
superloop is FATHER. */
|
|
|
static void
|
static void
|
establish_preds (struct loop *loop, struct loop *father)
|
establish_preds (struct loop *loop, struct loop *father)
|
{
|
{
|
loop_p ploop;
|
loop_p ploop;
|
unsigned depth = loop_depth (father) + 1;
|
unsigned depth = loop_depth (father) + 1;
|
unsigned i;
|
unsigned i;
|
|
|
VEC_truncate (loop_p, loop->superloops, 0);
|
VEC_truncate (loop_p, loop->superloops, 0);
|
VEC_reserve (loop_p, gc, loop->superloops, depth);
|
VEC_reserve (loop_p, gc, loop->superloops, depth);
|
for (i = 0; VEC_iterate (loop_p, father->superloops, i, ploop); i++)
|
for (i = 0; VEC_iterate (loop_p, father->superloops, i, ploop); i++)
|
VEC_quick_push (loop_p, loop->superloops, ploop);
|
VEC_quick_push (loop_p, loop->superloops, ploop);
|
VEC_quick_push (loop_p, loop->superloops, father);
|
VEC_quick_push (loop_p, loop->superloops, father);
|
|
|
for (ploop = loop->inner; ploop; ploop = ploop->next)
|
for (ploop = loop->inner; ploop; ploop = ploop->next)
|
establish_preds (ploop, loop);
|
establish_preds (ploop, loop);
|
}
|
}
|
|
|
/* Add LOOP to the loop hierarchy tree where FATHER is father of the
|
/* Add LOOP to the loop hierarchy tree where FATHER is father of the
|
added loop. If LOOP has some children, take care of that their
|
added loop. If LOOP has some children, take care of that their
|
pred field will be initialized correctly. */
|
pred field will be initialized correctly. */
|
|
|
void
|
void
|
flow_loop_tree_node_add (struct loop *father, struct loop *loop)
|
flow_loop_tree_node_add (struct loop *father, struct loop *loop)
|
{
|
{
|
loop->next = father->inner;
|
loop->next = father->inner;
|
father->inner = loop;
|
father->inner = loop;
|
|
|
establish_preds (loop, father);
|
establish_preds (loop, father);
|
}
|
}
|
|
|
/* Remove LOOP from the loop hierarchy tree. */
|
/* Remove LOOP from the loop hierarchy tree. */
|
|
|
void
|
void
|
flow_loop_tree_node_remove (struct loop *loop)
|
flow_loop_tree_node_remove (struct loop *loop)
|
{
|
{
|
struct loop *prev, *father;
|
struct loop *prev, *father;
|
|
|
father = loop_outer (loop);
|
father = loop_outer (loop);
|
|
|
/* Remove loop from the list of sons. */
|
/* Remove loop from the list of sons. */
|
if (father->inner == loop)
|
if (father->inner == loop)
|
father->inner = loop->next;
|
father->inner = loop->next;
|
else
|
else
|
{
|
{
|
for (prev = father->inner; prev->next != loop; prev = prev->next)
|
for (prev = father->inner; prev->next != loop; prev = prev->next)
|
continue;
|
continue;
|
prev->next = loop->next;
|
prev->next = loop->next;
|
}
|
}
|
|
|
VEC_truncate (loop_p, loop->superloops, 0);
|
VEC_truncate (loop_p, loop->superloops, 0);
|
}
|
}
|
|
|
/* Allocates and returns new loop structure. */
|
/* Allocates and returns new loop structure. */
|
|
|
struct loop *
|
struct loop *
|
alloc_loop (void)
|
alloc_loop (void)
|
{
|
{
|
struct loop *loop = GGC_CNEW (struct loop);
|
struct loop *loop = GGC_CNEW (struct loop);
|
|
|
loop->exits = GGC_CNEW (struct loop_exit);
|
loop->exits = GGC_CNEW (struct loop_exit);
|
loop->exits->next = loop->exits->prev = loop->exits;
|
loop->exits->next = loop->exits->prev = loop->exits;
|
loop->can_be_parallel = false;
|
loop->can_be_parallel = false;
|
loop->single_iv = NULL_TREE;
|
loop->single_iv = NULL_TREE;
|
|
|
return loop;
|
return loop;
|
}
|
}
|
|
|
/* Initializes loops structure LOOPS, reserving place for NUM_LOOPS loops
|
/* Initializes loops structure LOOPS, reserving place for NUM_LOOPS loops
|
(including the root of the loop tree). */
|
(including the root of the loop tree). */
|
|
|
static void
|
static void
|
init_loops_structure (struct loops *loops, unsigned num_loops)
|
init_loops_structure (struct loops *loops, unsigned num_loops)
|
{
|
{
|
struct loop *root;
|
struct loop *root;
|
|
|
memset (loops, 0, sizeof *loops);
|
memset (loops, 0, sizeof *loops);
|
loops->larray = VEC_alloc (loop_p, gc, num_loops);
|
loops->larray = VEC_alloc (loop_p, gc, num_loops);
|
|
|
/* Dummy loop containing whole function. */
|
/* Dummy loop containing whole function. */
|
root = alloc_loop ();
|
root = alloc_loop ();
|
root->num_nodes = n_basic_blocks;
|
root->num_nodes = n_basic_blocks;
|
root->latch = EXIT_BLOCK_PTR;
|
root->latch = EXIT_BLOCK_PTR;
|
root->header = ENTRY_BLOCK_PTR;
|
root->header = ENTRY_BLOCK_PTR;
|
ENTRY_BLOCK_PTR->loop_father = root;
|
ENTRY_BLOCK_PTR->loop_father = root;
|
EXIT_BLOCK_PTR->loop_father = root;
|
EXIT_BLOCK_PTR->loop_father = root;
|
|
|
VEC_quick_push (loop_p, loops->larray, root);
|
VEC_quick_push (loop_p, loops->larray, root);
|
loops->tree_root = root;
|
loops->tree_root = root;
|
}
|
}
|
|
|
/* Find all the natural loops in the function and save in LOOPS structure and
|
/* Find all the natural loops in the function and save in LOOPS structure and
|
recalculate loop_depth information in basic block structures.
|
recalculate loop_depth information in basic block structures.
|
Return the number of natural loops found. */
|
Return the number of natural loops found. */
|
|
|
int
|
int
|
flow_loops_find (struct loops *loops)
|
flow_loops_find (struct loops *loops)
|
{
|
{
|
int b;
|
int b;
|
int num_loops;
|
int num_loops;
|
edge e;
|
edge e;
|
sbitmap headers;
|
sbitmap headers;
|
int *dfs_order;
|
int *dfs_order;
|
int *rc_order;
|
int *rc_order;
|
basic_block header;
|
basic_block header;
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Ensure that the dominators are computed. */
|
/* Ensure that the dominators are computed. */
|
calculate_dominance_info (CDI_DOMINATORS);
|
calculate_dominance_info (CDI_DOMINATORS);
|
|
|
/* Taking care of this degenerate case makes the rest of
|
/* Taking care of this degenerate case makes the rest of
|
this code simpler. */
|
this code simpler. */
|
if (n_basic_blocks == NUM_FIXED_BLOCKS)
|
if (n_basic_blocks == NUM_FIXED_BLOCKS)
|
{
|
{
|
init_loops_structure (loops, 1);
|
init_loops_structure (loops, 1);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
dfs_order = NULL;
|
dfs_order = NULL;
|
rc_order = NULL;
|
rc_order = NULL;
|
|
|
/* Count the number of loop headers. This should be the
|
/* Count the number of loop headers. This should be the
|
same as the number of natural loops. */
|
same as the number of natural loops. */
|
headers = sbitmap_alloc (last_basic_block);
|
headers = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (headers);
|
sbitmap_zero (headers);
|
|
|
num_loops = 0;
|
num_loops = 0;
|
FOR_EACH_BB (header)
|
FOR_EACH_BB (header)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
header->loop_depth = 0;
|
header->loop_depth = 0;
|
|
|
/* If we have an abnormal predecessor, do not consider the
|
/* If we have an abnormal predecessor, do not consider the
|
loop (not worth the problems). */
|
loop (not worth the problems). */
|
FOR_EACH_EDGE (e, ei, header->preds)
|
FOR_EACH_EDGE (e, ei, header->preds)
|
if (e->flags & EDGE_ABNORMAL)
|
if (e->flags & EDGE_ABNORMAL)
|
break;
|
break;
|
if (e)
|
if (e)
|
continue;
|
continue;
|
|
|
FOR_EACH_EDGE (e, ei, header->preds)
|
FOR_EACH_EDGE (e, ei, header->preds)
|
{
|
{
|
basic_block latch = e->src;
|
basic_block latch = e->src;
|
|
|
gcc_assert (!(e->flags & EDGE_ABNORMAL));
|
gcc_assert (!(e->flags & EDGE_ABNORMAL));
|
|
|
/* Look for back edges where a predecessor is dominated
|
/* Look for back edges where a predecessor is dominated
|
by this block. A natural loop has a single entry
|
by this block. A natural loop has a single entry
|
node (header) that dominates all the nodes in the
|
node (header) that dominates all the nodes in the
|
loop. It also has single back edge to the header
|
loop. It also has single back edge to the header
|
from a latch node. */
|
from a latch node. */
|
if (latch != ENTRY_BLOCK_PTR
|
if (latch != ENTRY_BLOCK_PTR
|
&& dominated_by_p (CDI_DOMINATORS, latch, header))
|
&& dominated_by_p (CDI_DOMINATORS, latch, header))
|
{
|
{
|
/* Shared headers should be eliminated by now. */
|
/* Shared headers should be eliminated by now. */
|
SET_BIT (headers, header->index);
|
SET_BIT (headers, header->index);
|
num_loops++;
|
num_loops++;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Allocate loop structures. */
|
/* Allocate loop structures. */
|
init_loops_structure (loops, num_loops + 1);
|
init_loops_structure (loops, num_loops + 1);
|
|
|
/* Find and record information about all the natural loops
|
/* Find and record information about all the natural loops
|
in the CFG. */
|
in the CFG. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
bb->loop_father = loops->tree_root;
|
bb->loop_father = loops->tree_root;
|
|
|
if (num_loops)
|
if (num_loops)
|
{
|
{
|
/* Compute depth first search order of the CFG so that outer
|
/* Compute depth first search order of the CFG so that outer
|
natural loops will be found before inner natural loops. */
|
natural loops will be found before inner natural loops. */
|
dfs_order = XNEWVEC (int, n_basic_blocks);
|
dfs_order = XNEWVEC (int, n_basic_blocks);
|
rc_order = XNEWVEC (int, n_basic_blocks);
|
rc_order = XNEWVEC (int, n_basic_blocks);
|
pre_and_rev_post_order_compute (dfs_order, rc_order, false);
|
pre_and_rev_post_order_compute (dfs_order, rc_order, false);
|
|
|
num_loops = 1;
|
num_loops = 1;
|
|
|
for (b = 0; b < n_basic_blocks - NUM_FIXED_BLOCKS; b++)
|
for (b = 0; b < n_basic_blocks - NUM_FIXED_BLOCKS; b++)
|
{
|
{
|
struct loop *loop;
|
struct loop *loop;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
/* Search the nodes of the CFG in reverse completion order
|
/* Search the nodes of the CFG in reverse completion order
|
so that we can find outer loops first. */
|
so that we can find outer loops first. */
|
if (!TEST_BIT (headers, rc_order[b]))
|
if (!TEST_BIT (headers, rc_order[b]))
|
continue;
|
continue;
|
|
|
header = BASIC_BLOCK (rc_order[b]);
|
header = BASIC_BLOCK (rc_order[b]);
|
|
|
loop = alloc_loop ();
|
loop = alloc_loop ();
|
VEC_quick_push (loop_p, loops->larray, loop);
|
VEC_quick_push (loop_p, loops->larray, loop);
|
|
|
loop->header = header;
|
loop->header = header;
|
loop->num = num_loops;
|
loop->num = num_loops;
|
num_loops++;
|
num_loops++;
|
|
|
flow_loop_tree_node_add (header->loop_father, loop);
|
flow_loop_tree_node_add (header->loop_father, loop);
|
loop->num_nodes = flow_loop_nodes_find (loop->header, loop);
|
loop->num_nodes = flow_loop_nodes_find (loop->header, loop);
|
|
|
/* Look for the latch for this header block, if it has just a
|
/* Look for the latch for this header block, if it has just a
|
single one. */
|
single one. */
|
FOR_EACH_EDGE (e, ei, header->preds)
|
FOR_EACH_EDGE (e, ei, header->preds)
|
{
|
{
|
basic_block latch = e->src;
|
basic_block latch = e->src;
|
|
|
if (flow_bb_inside_loop_p (loop, latch))
|
if (flow_bb_inside_loop_p (loop, latch))
|
{
|
{
|
if (loop->latch != NULL)
|
if (loop->latch != NULL)
|
{
|
{
|
/* More than one latch edge. */
|
/* More than one latch edge. */
|
loop->latch = NULL;
|
loop->latch = NULL;
|
break;
|
break;
|
}
|
}
|
loop->latch = latch;
|
loop->latch = latch;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
free (dfs_order);
|
free (dfs_order);
|
free (rc_order);
|
free (rc_order);
|
}
|
}
|
|
|
sbitmap_free (headers);
|
sbitmap_free (headers);
|
|
|
loops->exits = NULL;
|
loops->exits = NULL;
|
return VEC_length (loop_p, loops->larray);
|
return VEC_length (loop_p, loops->larray);
|
}
|
}
|
|
|
/* Ratio of frequencies of edges so that one of more latch edges is
|
/* Ratio of frequencies of edges so that one of more latch edges is
|
considered to belong to inner loop with same header. */
|
considered to belong to inner loop with same header. */
|
#define HEAVY_EDGE_RATIO 8
|
#define HEAVY_EDGE_RATIO 8
|
|
|
/* Minimum number of samples for that we apply
|
/* Minimum number of samples for that we apply
|
find_subloop_latch_edge_by_profile heuristics. */
|
find_subloop_latch_edge_by_profile heuristics. */
|
#define HEAVY_EDGE_MIN_SAMPLES 10
|
#define HEAVY_EDGE_MIN_SAMPLES 10
|
|
|
/* If the profile info is available, finds an edge in LATCHES that much more
|
/* If the profile info is available, finds an edge in LATCHES that much more
|
frequent than the remaining edges. Returns such an edge, or NULL if we do
|
frequent than the remaining edges. Returns such an edge, or NULL if we do
|
not find one.
|
not find one.
|
|
|
We do not use guessed profile here, only the measured one. The guessed
|
We do not use guessed profile here, only the measured one. The guessed
|
profile is usually too flat and unreliable for this (and it is mostly based
|
profile is usually too flat and unreliable for this (and it is mostly based
|
on the loop structure of the program, so it does not make much sense to
|
on the loop structure of the program, so it does not make much sense to
|
derive the loop structure from it). */
|
derive the loop structure from it). */
|
|
|
static edge
|
static edge
|
find_subloop_latch_edge_by_profile (VEC (edge, heap) *latches)
|
find_subloop_latch_edge_by_profile (VEC (edge, heap) *latches)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
edge e, me = NULL;
|
edge e, me = NULL;
|
gcov_type mcount = 0, tcount = 0;
|
gcov_type mcount = 0, tcount = 0;
|
|
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
{
|
{
|
if (e->count > mcount)
|
if (e->count > mcount)
|
{
|
{
|
me = e;
|
me = e;
|
mcount = e->count;
|
mcount = e->count;
|
}
|
}
|
tcount += e->count;
|
tcount += e->count;
|
}
|
}
|
|
|
if (tcount < HEAVY_EDGE_MIN_SAMPLES
|
if (tcount < HEAVY_EDGE_MIN_SAMPLES
|
|| (tcount - mcount) * HEAVY_EDGE_RATIO > tcount)
|
|| (tcount - mcount) * HEAVY_EDGE_RATIO > tcount)
|
return NULL;
|
return NULL;
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Found latch edge %d -> %d using profile information.\n",
|
"Found latch edge %d -> %d using profile information.\n",
|
me->src->index, me->dest->index);
|
me->src->index, me->dest->index);
|
return me;
|
return me;
|
}
|
}
|
|
|
/* Among LATCHES, guesses a latch edge of LOOP corresponding to subloop, based
|
/* Among LATCHES, guesses a latch edge of LOOP corresponding to subloop, based
|
on the structure of induction variables. Returns this edge, or NULL if we
|
on the structure of induction variables. Returns this edge, or NULL if we
|
do not find any.
|
do not find any.
|
|
|
We are quite conservative, and look just for an obvious simple innermost
|
We are quite conservative, and look just for an obvious simple innermost
|
loop (which is the case where we would lose the most performance by not
|
loop (which is the case where we would lose the most performance by not
|
disambiguating the loop). More precisely, we look for the following
|
disambiguating the loop). More precisely, we look for the following
|
situation: The source of the chosen latch edge dominates sources of all
|
situation: The source of the chosen latch edge dominates sources of all
|
the other latch edges. Additionally, the header does not contain a phi node
|
the other latch edges. Additionally, the header does not contain a phi node
|
such that the argument from the chosen edge is equal to the argument from
|
such that the argument from the chosen edge is equal to the argument from
|
another edge. */
|
another edge. */
|
|
|
static edge
|
static edge
|
find_subloop_latch_edge_by_ivs (struct loop *loop ATTRIBUTE_UNUSED, VEC (edge, heap) *latches)
|
find_subloop_latch_edge_by_ivs (struct loop *loop ATTRIBUTE_UNUSED, VEC (edge, heap) *latches)
|
{
|
{
|
edge e, latch = VEC_index (edge, latches, 0);
|
edge e, latch = VEC_index (edge, latches, 0);
|
unsigned i;
|
unsigned i;
|
gimple phi;
|
gimple phi;
|
gimple_stmt_iterator psi;
|
gimple_stmt_iterator psi;
|
tree lop;
|
tree lop;
|
basic_block bb;
|
basic_block bb;
|
|
|
/* Find the candidate for the latch edge. */
|
/* Find the candidate for the latch edge. */
|
for (i = 1; VEC_iterate (edge, latches, i, e); i++)
|
for (i = 1; VEC_iterate (edge, latches, i, e); i++)
|
if (dominated_by_p (CDI_DOMINATORS, latch->src, e->src))
|
if (dominated_by_p (CDI_DOMINATORS, latch->src, e->src))
|
latch = e;
|
latch = e;
|
|
|
/* Verify that it dominates all the latch edges. */
|
/* Verify that it dominates all the latch edges. */
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
if (!dominated_by_p (CDI_DOMINATORS, e->src, latch->src))
|
if (!dominated_by_p (CDI_DOMINATORS, e->src, latch->src))
|
return NULL;
|
return NULL;
|
|
|
/* Check for a phi node that would deny that this is a latch edge of
|
/* Check for a phi node that would deny that this is a latch edge of
|
a subloop. */
|
a subloop. */
|
for (psi = gsi_start_phis (loop->header); !gsi_end_p (psi); gsi_next (&psi))
|
for (psi = gsi_start_phis (loop->header); !gsi_end_p (psi); gsi_next (&psi))
|
{
|
{
|
phi = gsi_stmt (psi);
|
phi = gsi_stmt (psi);
|
lop = PHI_ARG_DEF_FROM_EDGE (phi, latch);
|
lop = PHI_ARG_DEF_FROM_EDGE (phi, latch);
|
|
|
/* Ignore the values that are not changed inside the subloop. */
|
/* Ignore the values that are not changed inside the subloop. */
|
if (TREE_CODE (lop) != SSA_NAME
|
if (TREE_CODE (lop) != SSA_NAME
|
|| SSA_NAME_DEF_STMT (lop) == phi)
|
|| SSA_NAME_DEF_STMT (lop) == phi)
|
continue;
|
continue;
|
bb = gimple_bb (SSA_NAME_DEF_STMT (lop));
|
bb = gimple_bb (SSA_NAME_DEF_STMT (lop));
|
if (!bb || !flow_bb_inside_loop_p (loop, bb))
|
if (!bb || !flow_bb_inside_loop_p (loop, bb))
|
continue;
|
continue;
|
|
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
if (e != latch
|
if (e != latch
|
&& PHI_ARG_DEF_FROM_EDGE (phi, e) == lop)
|
&& PHI_ARG_DEF_FROM_EDGE (phi, e) == lop)
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file,
|
fprintf (dump_file,
|
"Found latch edge %d -> %d using iv structure.\n",
|
"Found latch edge %d -> %d using iv structure.\n",
|
latch->src->index, latch->dest->index);
|
latch->src->index, latch->dest->index);
|
return latch;
|
return latch;
|
}
|
}
|
|
|
/* If we can determine that one of the several latch edges of LOOP behaves
|
/* If we can determine that one of the several latch edges of LOOP behaves
|
as a latch edge of a separate subloop, returns this edge. Otherwise
|
as a latch edge of a separate subloop, returns this edge. Otherwise
|
returns NULL. */
|
returns NULL. */
|
|
|
static edge
|
static edge
|
find_subloop_latch_edge (struct loop *loop)
|
find_subloop_latch_edge (struct loop *loop)
|
{
|
{
|
VEC (edge, heap) *latches = get_loop_latch_edges (loop);
|
VEC (edge, heap) *latches = get_loop_latch_edges (loop);
|
edge latch = NULL;
|
edge latch = NULL;
|
|
|
if (VEC_length (edge, latches) > 1)
|
if (VEC_length (edge, latches) > 1)
|
{
|
{
|
latch = find_subloop_latch_edge_by_profile (latches);
|
latch = find_subloop_latch_edge_by_profile (latches);
|
|
|
if (!latch
|
if (!latch
|
/* We consider ivs to guess the latch edge only in SSA. Perhaps we
|
/* We consider ivs to guess the latch edge only in SSA. Perhaps we
|
should use cfghook for this, but it is hard to imagine it would
|
should use cfghook for this, but it is hard to imagine it would
|
be useful elsewhere. */
|
be useful elsewhere. */
|
&& current_ir_type () == IR_GIMPLE)
|
&& current_ir_type () == IR_GIMPLE)
|
latch = find_subloop_latch_edge_by_ivs (loop, latches);
|
latch = find_subloop_latch_edge_by_ivs (loop, latches);
|
}
|
}
|
|
|
VEC_free (edge, heap, latches);
|
VEC_free (edge, heap, latches);
|
return latch;
|
return latch;
|
}
|
}
|
|
|
/* Callback for make_forwarder_block. Returns true if the edge E is marked
|
/* Callback for make_forwarder_block. Returns true if the edge E is marked
|
in the set MFB_REIS_SET. */
|
in the set MFB_REIS_SET. */
|
|
|
static struct pointer_set_t *mfb_reis_set;
|
static struct pointer_set_t *mfb_reis_set;
|
static bool
|
static bool
|
mfb_redirect_edges_in_set (edge e)
|
mfb_redirect_edges_in_set (edge e)
|
{
|
{
|
return pointer_set_contains (mfb_reis_set, e);
|
return pointer_set_contains (mfb_reis_set, e);
|
}
|
}
|
|
|
/* Creates a subloop of LOOP with latch edge LATCH. */
|
/* Creates a subloop of LOOP with latch edge LATCH. */
|
|
|
static void
|
static void
|
form_subloop (struct loop *loop, edge latch)
|
form_subloop (struct loop *loop, edge latch)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e, new_entry;
|
edge e, new_entry;
|
struct loop *new_loop;
|
struct loop *new_loop;
|
|
|
mfb_reis_set = pointer_set_create ();
|
mfb_reis_set = pointer_set_create ();
|
FOR_EACH_EDGE (e, ei, loop->header->preds)
|
FOR_EACH_EDGE (e, ei, loop->header->preds)
|
{
|
{
|
if (e != latch)
|
if (e != latch)
|
pointer_set_insert (mfb_reis_set, e);
|
pointer_set_insert (mfb_reis_set, e);
|
}
|
}
|
new_entry = make_forwarder_block (loop->header, mfb_redirect_edges_in_set,
|
new_entry = make_forwarder_block (loop->header, mfb_redirect_edges_in_set,
|
NULL);
|
NULL);
|
pointer_set_destroy (mfb_reis_set);
|
pointer_set_destroy (mfb_reis_set);
|
|
|
loop->header = new_entry->src;
|
loop->header = new_entry->src;
|
|
|
/* Find the blocks and subloops that belong to the new loop, and add it to
|
/* Find the blocks and subloops that belong to the new loop, and add it to
|
the appropriate place in the loop tree. */
|
the appropriate place in the loop tree. */
|
new_loop = alloc_loop ();
|
new_loop = alloc_loop ();
|
new_loop->header = new_entry->dest;
|
new_loop->header = new_entry->dest;
|
new_loop->latch = latch->src;
|
new_loop->latch = latch->src;
|
add_loop (new_loop, loop);
|
add_loop (new_loop, loop);
|
}
|
}
|
|
|
/* Make all the latch edges of LOOP to go to a single forwarder block --
|
/* Make all the latch edges of LOOP to go to a single forwarder block --
|
a new latch of LOOP. */
|
a new latch of LOOP. */
|
|
|
static void
|
static void
|
merge_latch_edges (struct loop *loop)
|
merge_latch_edges (struct loop *loop)
|
{
|
{
|
VEC (edge, heap) *latches = get_loop_latch_edges (loop);
|
VEC (edge, heap) *latches = get_loop_latch_edges (loop);
|
edge latch, e;
|
edge latch, e;
|
unsigned i;
|
unsigned i;
|
|
|
gcc_assert (VEC_length (edge, latches) > 0);
|
gcc_assert (VEC_length (edge, latches) > 0);
|
|
|
if (VEC_length (edge, latches) == 1)
|
if (VEC_length (edge, latches) == 1)
|
loop->latch = VEC_index (edge, latches, 0)->src;
|
loop->latch = VEC_index (edge, latches, 0)->src;
|
else
|
else
|
{
|
{
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Merged latch edges of loop %d\n", loop->num);
|
fprintf (dump_file, "Merged latch edges of loop %d\n", loop->num);
|
|
|
mfb_reis_set = pointer_set_create ();
|
mfb_reis_set = pointer_set_create ();
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
for (i = 0; VEC_iterate (edge, latches, i, e); i++)
|
pointer_set_insert (mfb_reis_set, e);
|
pointer_set_insert (mfb_reis_set, e);
|
latch = make_forwarder_block (loop->header, mfb_redirect_edges_in_set,
|
latch = make_forwarder_block (loop->header, mfb_redirect_edges_in_set,
|
NULL);
|
NULL);
|
pointer_set_destroy (mfb_reis_set);
|
pointer_set_destroy (mfb_reis_set);
|
|
|
loop->header = latch->dest;
|
loop->header = latch->dest;
|
loop->latch = latch->src;
|
loop->latch = latch->src;
|
}
|
}
|
|
|
VEC_free (edge, heap, latches);
|
VEC_free (edge, heap, latches);
|
}
|
}
|
|
|
/* LOOP may have several latch edges. Transform it into (possibly several)
|
/* LOOP may have several latch edges. Transform it into (possibly several)
|
loops with single latch edge. */
|
loops with single latch edge. */
|
|
|
static void
|
static void
|
disambiguate_multiple_latches (struct loop *loop)
|
disambiguate_multiple_latches (struct loop *loop)
|
{
|
{
|
edge e;
|
edge e;
|
|
|
/* We eliminate the multiple latches by splitting the header to the forwarder
|
/* We eliminate the multiple latches by splitting the header to the forwarder
|
block F and the rest R, and redirecting the edges. There are two cases:
|
block F and the rest R, and redirecting the edges. There are two cases:
|
|
|
1) If there is a latch edge E that corresponds to a subloop (we guess
|
1) If there is a latch edge E that corresponds to a subloop (we guess
|
that based on profile -- if it is taken much more often than the
|
that based on profile -- if it is taken much more often than the
|
remaining edges; and on trees, using the information about induction
|
remaining edges; and on trees, using the information about induction
|
variables of the loops), we redirect E to R, all the remaining edges to
|
variables of the loops), we redirect E to R, all the remaining edges to
|
F, then rescan the loops and try again for the outer loop.
|
F, then rescan the loops and try again for the outer loop.
|
2) If there is no such edge, we redirect all latch edges to F, and the
|
2) If there is no such edge, we redirect all latch edges to F, and the
|
entry edges to R, thus making F the single latch of the loop. */
|
entry edges to R, thus making F the single latch of the loop. */
|
|
|
if (dump_file)
|
if (dump_file)
|
fprintf (dump_file, "Disambiguating loop %d with multiple latches\n",
|
fprintf (dump_file, "Disambiguating loop %d with multiple latches\n",
|
loop->num);
|
loop->num);
|
|
|
/* During latch merging, we may need to redirect the entry edges to a new
|
/* During latch merging, we may need to redirect the entry edges to a new
|
block. This would cause problems if the entry edge was the one from the
|
block. This would cause problems if the entry edge was the one from the
|
entry block. To avoid having to handle this case specially, split
|
entry block. To avoid having to handle this case specially, split
|
such entry edge. */
|
such entry edge. */
|
e = find_edge (ENTRY_BLOCK_PTR, loop->header);
|
e = find_edge (ENTRY_BLOCK_PTR, loop->header);
|
if (e)
|
if (e)
|
split_edge (e);
|
split_edge (e);
|
|
|
while (1)
|
while (1)
|
{
|
{
|
e = find_subloop_latch_edge (loop);
|
e = find_subloop_latch_edge (loop);
|
if (!e)
|
if (!e)
|
break;
|
break;
|
|
|
form_subloop (loop, e);
|
form_subloop (loop, e);
|
}
|
}
|
|
|
merge_latch_edges (loop);
|
merge_latch_edges (loop);
|
}
|
}
|
|
|
/* Split loops with multiple latch edges. */
|
/* Split loops with multiple latch edges. */
|
|
|
void
|
void
|
disambiguate_loops_with_multiple_latches (void)
|
disambiguate_loops_with_multiple_latches (void)
|
{
|
{
|
loop_iterator li;
|
loop_iterator li;
|
struct loop *loop;
|
struct loop *loop;
|
|
|
FOR_EACH_LOOP (li, loop, 0)
|
FOR_EACH_LOOP (li, loop, 0)
|
{
|
{
|
if (!loop->latch)
|
if (!loop->latch)
|
disambiguate_multiple_latches (loop);
|
disambiguate_multiple_latches (loop);
|
}
|
}
|
}
|
}
|
|
|
/* Return nonzero if basic block BB belongs to LOOP. */
|
/* Return nonzero if basic block BB belongs to LOOP. */
|
bool
|
bool
|
flow_bb_inside_loop_p (const struct loop *loop, const_basic_block bb)
|
flow_bb_inside_loop_p (const struct loop *loop, const_basic_block bb)
|
{
|
{
|
struct loop *source_loop;
|
struct loop *source_loop;
|
|
|
if (bb == ENTRY_BLOCK_PTR || bb == EXIT_BLOCK_PTR)
|
if (bb == ENTRY_BLOCK_PTR || bb == EXIT_BLOCK_PTR)
|
return 0;
|
return 0;
|
|
|
source_loop = bb->loop_father;
|
source_loop = bb->loop_father;
|
return loop == source_loop || flow_loop_nested_p (loop, source_loop);
|
return loop == source_loop || flow_loop_nested_p (loop, source_loop);
|
}
|
}
|
|
|
/* Enumeration predicate for get_loop_body_with_size. */
|
/* Enumeration predicate for get_loop_body_with_size. */
|
static bool
|
static bool
|
glb_enum_p (const_basic_block bb, const void *glb_loop)
|
glb_enum_p (const_basic_block bb, const void *glb_loop)
|
{
|
{
|
const struct loop *const loop = (const struct loop *) glb_loop;
|
const struct loop *const loop = (const struct loop *) glb_loop;
|
return (bb != loop->header
|
return (bb != loop->header
|
&& dominated_by_p (CDI_DOMINATORS, bb, loop->header));
|
&& dominated_by_p (CDI_DOMINATORS, bb, loop->header));
|
}
|
}
|
|
|
/* Gets basic blocks of a LOOP. Header is the 0-th block, rest is in dfs
|
/* Gets basic blocks of a LOOP. Header is the 0-th block, rest is in dfs
|
order against direction of edges from latch. Specially, if
|
order against direction of edges from latch. Specially, if
|
header != latch, latch is the 1-st block. LOOP cannot be the fake
|
header != latch, latch is the 1-st block. LOOP cannot be the fake
|
loop tree root, and its size must be at most MAX_SIZE. The blocks
|
loop tree root, and its size must be at most MAX_SIZE. The blocks
|
in the LOOP body are stored to BODY, and the size of the LOOP is
|
in the LOOP body are stored to BODY, and the size of the LOOP is
|
returned. */
|
returned. */
|
|
|
unsigned
|
unsigned
|
get_loop_body_with_size (const struct loop *loop, basic_block *body,
|
get_loop_body_with_size (const struct loop *loop, basic_block *body,
|
unsigned max_size)
|
unsigned max_size)
|
{
|
{
|
return dfs_enumerate_from (loop->header, 1, glb_enum_p,
|
return dfs_enumerate_from (loop->header, 1, glb_enum_p,
|
body, max_size, loop);
|
body, max_size, loop);
|
}
|
}
|
|
|
/* Gets basic blocks of a LOOP. Header is the 0-th block, rest is in dfs
|
/* Gets basic blocks of a LOOP. Header is the 0-th block, rest is in dfs
|
order against direction of edges from latch. Specially, if
|
order against direction of edges from latch. Specially, if
|
header != latch, latch is the 1-st block. */
|
header != latch, latch is the 1-st block. */
|
|
|
basic_block *
|
basic_block *
|
get_loop_body (const struct loop *loop)
|
get_loop_body (const struct loop *loop)
|
{
|
{
|
basic_block *body, bb;
|
basic_block *body, bb;
|
unsigned tv = 0;
|
unsigned tv = 0;
|
|
|
gcc_assert (loop->num_nodes);
|
gcc_assert (loop->num_nodes);
|
|
|
body = XCNEWVEC (basic_block, loop->num_nodes);
|
body = XCNEWVEC (basic_block, loop->num_nodes);
|
|
|
if (loop->latch == EXIT_BLOCK_PTR)
|
if (loop->latch == EXIT_BLOCK_PTR)
|
{
|
{
|
/* There may be blocks unreachable from EXIT_BLOCK, hence we need to
|
/* There may be blocks unreachable from EXIT_BLOCK, hence we need to
|
special-case the fake loop that contains the whole function. */
|
special-case the fake loop that contains the whole function. */
|
gcc_assert (loop->num_nodes == (unsigned) n_basic_blocks);
|
gcc_assert (loop->num_nodes == (unsigned) n_basic_blocks);
|
body[tv++] = loop->header;
|
body[tv++] = loop->header;
|
body[tv++] = EXIT_BLOCK_PTR;
|
body[tv++] = EXIT_BLOCK_PTR;
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
body[tv++] = bb;
|
body[tv++] = bb;
|
}
|
}
|
else
|
else
|
tv = get_loop_body_with_size (loop, body, loop->num_nodes);
|
tv = get_loop_body_with_size (loop, body, loop->num_nodes);
|
|
|
gcc_assert (tv == loop->num_nodes);
|
gcc_assert (tv == loop->num_nodes);
|
return body;
|
return body;
|
}
|
}
|
|
|
/* Fills dominance descendants inside LOOP of the basic block BB into
|
/* Fills dominance descendants inside LOOP of the basic block BB into
|
array TOVISIT from index *TV. */
|
array TOVISIT from index *TV. */
|
|
|
static void
|
static void
|
fill_sons_in_loop (const struct loop *loop, basic_block bb,
|
fill_sons_in_loop (const struct loop *loop, basic_block bb,
|
basic_block *tovisit, int *tv)
|
basic_block *tovisit, int *tv)
|
{
|
{
|
basic_block son, postpone = NULL;
|
basic_block son, postpone = NULL;
|
|
|
tovisit[(*tv)++] = bb;
|
tovisit[(*tv)++] = bb;
|
for (son = first_dom_son (CDI_DOMINATORS, bb);
|
for (son = first_dom_son (CDI_DOMINATORS, bb);
|
son;
|
son;
|
son = next_dom_son (CDI_DOMINATORS, son))
|
son = next_dom_son (CDI_DOMINATORS, son))
|
{
|
{
|
if (!flow_bb_inside_loop_p (loop, son))
|
if (!flow_bb_inside_loop_p (loop, son))
|
continue;
|
continue;
|
|
|
if (dominated_by_p (CDI_DOMINATORS, loop->latch, son))
|
if (dominated_by_p (CDI_DOMINATORS, loop->latch, son))
|
{
|
{
|
postpone = son;
|
postpone = son;
|
continue;
|
continue;
|
}
|
}
|
fill_sons_in_loop (loop, son, tovisit, tv);
|
fill_sons_in_loop (loop, son, tovisit, tv);
|
}
|
}
|
|
|
if (postpone)
|
if (postpone)
|
fill_sons_in_loop (loop, postpone, tovisit, tv);
|
fill_sons_in_loop (loop, postpone, tovisit, tv);
|
}
|
}
|
|
|
/* Gets body of a LOOP (that must be different from the outermost loop)
|
/* Gets body of a LOOP (that must be different from the outermost loop)
|
sorted by dominance relation. Additionally, if a basic block s dominates
|
sorted by dominance relation. Additionally, if a basic block s dominates
|
the latch, then only blocks dominated by s are be after it. */
|
the latch, then only blocks dominated by s are be after it. */
|
|
|
basic_block *
|
basic_block *
|
get_loop_body_in_dom_order (const struct loop *loop)
|
get_loop_body_in_dom_order (const struct loop *loop)
|
{
|
{
|
basic_block *tovisit;
|
basic_block *tovisit;
|
int tv;
|
int tv;
|
|
|
gcc_assert (loop->num_nodes);
|
gcc_assert (loop->num_nodes);
|
|
|
tovisit = XCNEWVEC (basic_block, loop->num_nodes);
|
tovisit = XCNEWVEC (basic_block, loop->num_nodes);
|
|
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
|
|
tv = 0;
|
tv = 0;
|
fill_sons_in_loop (loop, loop->header, tovisit, &tv);
|
fill_sons_in_loop (loop, loop->header, tovisit, &tv);
|
|
|
gcc_assert (tv == (int) loop->num_nodes);
|
gcc_assert (tv == (int) loop->num_nodes);
|
|
|
return tovisit;
|
return tovisit;
|
}
|
}
|
|
|
/* Gets body of a LOOP sorted via provided BB_COMPARATOR. */
|
/* Gets body of a LOOP sorted via provided BB_COMPARATOR. */
|
|
|
basic_block *
|
basic_block *
|
get_loop_body_in_custom_order (const struct loop *loop,
|
get_loop_body_in_custom_order (const struct loop *loop,
|
int (*bb_comparator) (const void *, const void *))
|
int (*bb_comparator) (const void *, const void *))
|
{
|
{
|
basic_block *bbs = get_loop_body (loop);
|
basic_block *bbs = get_loop_body (loop);
|
|
|
qsort (bbs, loop->num_nodes, sizeof (basic_block), bb_comparator);
|
qsort (bbs, loop->num_nodes, sizeof (basic_block), bb_comparator);
|
|
|
return bbs;
|
return bbs;
|
}
|
}
|
|
|
/* Get body of a LOOP in breadth first sort order. */
|
/* Get body of a LOOP in breadth first sort order. */
|
|
|
basic_block *
|
basic_block *
|
get_loop_body_in_bfs_order (const struct loop *loop)
|
get_loop_body_in_bfs_order (const struct loop *loop)
|
{
|
{
|
basic_block *blocks;
|
basic_block *blocks;
|
basic_block bb;
|
basic_block bb;
|
bitmap visited;
|
bitmap visited;
|
unsigned int i = 0;
|
unsigned int i = 0;
|
unsigned int vc = 1;
|
unsigned int vc = 1;
|
|
|
gcc_assert (loop->num_nodes);
|
gcc_assert (loop->num_nodes);
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
|
|
blocks = XCNEWVEC (basic_block, loop->num_nodes);
|
blocks = XCNEWVEC (basic_block, loop->num_nodes);
|
visited = BITMAP_ALLOC (NULL);
|
visited = BITMAP_ALLOC (NULL);
|
|
|
bb = loop->header;
|
bb = loop->header;
|
while (i < loop->num_nodes)
|
while (i < loop->num_nodes)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
if (!bitmap_bit_p (visited, bb->index))
|
if (!bitmap_bit_p (visited, bb->index))
|
{
|
{
|
/* This basic block is now visited */
|
/* This basic block is now visited */
|
bitmap_set_bit (visited, bb->index);
|
bitmap_set_bit (visited, bb->index);
|
blocks[i++] = bb;
|
blocks[i++] = bb;
|
}
|
}
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
{
|
{
|
if (flow_bb_inside_loop_p (loop, e->dest))
|
if (flow_bb_inside_loop_p (loop, e->dest))
|
{
|
{
|
if (!bitmap_bit_p (visited, e->dest->index))
|
if (!bitmap_bit_p (visited, e->dest->index))
|
{
|
{
|
bitmap_set_bit (visited, e->dest->index);
|
bitmap_set_bit (visited, e->dest->index);
|
blocks[i++] = e->dest;
|
blocks[i++] = e->dest;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
gcc_assert (i >= vc);
|
gcc_assert (i >= vc);
|
|
|
bb = blocks[vc++];
|
bb = blocks[vc++];
|
}
|
}
|
|
|
BITMAP_FREE (visited);
|
BITMAP_FREE (visited);
|
return blocks;
|
return blocks;
|
}
|
}
|
|
|
/* Hash function for struct loop_exit. */
|
/* Hash function for struct loop_exit. */
|
|
|
static hashval_t
|
static hashval_t
|
loop_exit_hash (const void *ex)
|
loop_exit_hash (const void *ex)
|
{
|
{
|
const struct loop_exit *const exit = (const struct loop_exit *) ex;
|
const struct loop_exit *const exit = (const struct loop_exit *) ex;
|
|
|
return htab_hash_pointer (exit->e);
|
return htab_hash_pointer (exit->e);
|
}
|
}
|
|
|
/* Equality function for struct loop_exit. Compares with edge. */
|
/* Equality function for struct loop_exit. Compares with edge. */
|
|
|
static int
|
static int
|
loop_exit_eq (const void *ex, const void *e)
|
loop_exit_eq (const void *ex, const void *e)
|
{
|
{
|
const struct loop_exit *const exit = (const struct loop_exit *) ex;
|
const struct loop_exit *const exit = (const struct loop_exit *) ex;
|
|
|
return exit->e == e;
|
return exit->e == e;
|
}
|
}
|
|
|
/* Frees the list of loop exit descriptions EX. */
|
/* Frees the list of loop exit descriptions EX. */
|
|
|
static void
|
static void
|
loop_exit_free (void *ex)
|
loop_exit_free (void *ex)
|
{
|
{
|
struct loop_exit *exit = (struct loop_exit *) ex, *next;
|
struct loop_exit *exit = (struct loop_exit *) ex, *next;
|
|
|
for (; exit; exit = next)
|
for (; exit; exit = next)
|
{
|
{
|
next = exit->next_e;
|
next = exit->next_e;
|
|
|
exit->next->prev = exit->prev;
|
exit->next->prev = exit->prev;
|
exit->prev->next = exit->next;
|
exit->prev->next = exit->next;
|
|
|
ggc_free (exit);
|
ggc_free (exit);
|
}
|
}
|
}
|
}
|
|
|
/* Returns the list of records for E as an exit of a loop. */
|
/* Returns the list of records for E as an exit of a loop. */
|
|
|
static struct loop_exit *
|
static struct loop_exit *
|
get_exit_descriptions (edge e)
|
get_exit_descriptions (edge e)
|
{
|
{
|
return (struct loop_exit *) htab_find_with_hash (current_loops->exits, e,
|
return (struct loop_exit *) htab_find_with_hash (current_loops->exits, e,
|
htab_hash_pointer (e));
|
htab_hash_pointer (e));
|
}
|
}
|
|
|
/* Updates the lists of loop exits in that E appears.
|
/* Updates the lists of loop exits in that E appears.
|
If REMOVED is true, E is being removed, and we
|
If REMOVED is true, E is being removed, and we
|
just remove it from the lists of exits.
|
just remove it from the lists of exits.
|
If NEW_EDGE is true and E is not a loop exit, we
|
If NEW_EDGE is true and E is not a loop exit, we
|
do not try to remove it from loop exit lists. */
|
do not try to remove it from loop exit lists. */
|
|
|
void
|
void
|
rescan_loop_exit (edge e, bool new_edge, bool removed)
|
rescan_loop_exit (edge e, bool new_edge, bool removed)
|
{
|
{
|
void **slot;
|
void **slot;
|
struct loop_exit *exits = NULL, *exit;
|
struct loop_exit *exits = NULL, *exit;
|
struct loop *aloop, *cloop;
|
struct loop *aloop, *cloop;
|
|
|
if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
return;
|
return;
|
|
|
if (!removed
|
if (!removed
|
&& e->src->loop_father != NULL
|
&& e->src->loop_father != NULL
|
&& e->dest->loop_father != NULL
|
&& e->dest->loop_father != NULL
|
&& !flow_bb_inside_loop_p (e->src->loop_father, e->dest))
|
&& !flow_bb_inside_loop_p (e->src->loop_father, e->dest))
|
{
|
{
|
cloop = find_common_loop (e->src->loop_father, e->dest->loop_father);
|
cloop = find_common_loop (e->src->loop_father, e->dest->loop_father);
|
for (aloop = e->src->loop_father;
|
for (aloop = e->src->loop_father;
|
aloop != cloop;
|
aloop != cloop;
|
aloop = loop_outer (aloop))
|
aloop = loop_outer (aloop))
|
{
|
{
|
exit = GGC_NEW (struct loop_exit);
|
exit = GGC_NEW (struct loop_exit);
|
exit->e = e;
|
exit->e = e;
|
|
|
exit->next = aloop->exits->next;
|
exit->next = aloop->exits->next;
|
exit->prev = aloop->exits;
|
exit->prev = aloop->exits;
|
exit->next->prev = exit;
|
exit->next->prev = exit;
|
exit->prev->next = exit;
|
exit->prev->next = exit;
|
|
|
exit->next_e = exits;
|
exit->next_e = exits;
|
exits = exit;
|
exits = exit;
|
}
|
}
|
}
|
}
|
|
|
if (!exits && new_edge)
|
if (!exits && new_edge)
|
return;
|
return;
|
|
|
slot = htab_find_slot_with_hash (current_loops->exits, e,
|
slot = htab_find_slot_with_hash (current_loops->exits, e,
|
htab_hash_pointer (e),
|
htab_hash_pointer (e),
|
exits ? INSERT : NO_INSERT);
|
exits ? INSERT : NO_INSERT);
|
if (!slot)
|
if (!slot)
|
return;
|
return;
|
|
|
if (exits)
|
if (exits)
|
{
|
{
|
if (*slot)
|
if (*slot)
|
loop_exit_free (*slot);
|
loop_exit_free (*slot);
|
*slot = exits;
|
*slot = exits;
|
}
|
}
|
else
|
else
|
htab_clear_slot (current_loops->exits, slot);
|
htab_clear_slot (current_loops->exits, slot);
|
}
|
}
|
|
|
/* For each loop, record list of exit edges, and start maintaining these
|
/* For each loop, record list of exit edges, and start maintaining these
|
lists. */
|
lists. */
|
|
|
void
|
void
|
record_loop_exits (void)
|
record_loop_exits (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
if (!current_loops)
|
if (!current_loops)
|
return;
|
return;
|
|
|
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
return;
|
return;
|
loops_state_set (LOOPS_HAVE_RECORDED_EXITS);
|
loops_state_set (LOOPS_HAVE_RECORDED_EXITS);
|
|
|
gcc_assert (current_loops->exits == NULL);
|
gcc_assert (current_loops->exits == NULL);
|
current_loops->exits = htab_create_alloc (2 * number_of_loops (),
|
current_loops->exits = htab_create_alloc (2 * number_of_loops (),
|
loop_exit_hash,
|
loop_exit_hash,
|
loop_exit_eq,
|
loop_exit_eq,
|
loop_exit_free,
|
loop_exit_free,
|
ggc_calloc, ggc_free);
|
ggc_calloc, ggc_free);
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
{
|
{
|
rescan_loop_exit (e, true, false);
|
rescan_loop_exit (e, true, false);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Dumps information about the exit in *SLOT to FILE.
|
/* Dumps information about the exit in *SLOT to FILE.
|
Callback for htab_traverse. */
|
Callback for htab_traverse. */
|
|
|
static int
|
static int
|
dump_recorded_exit (void **slot, void *file)
|
dump_recorded_exit (void **slot, void *file)
|
{
|
{
|
struct loop_exit *exit = (struct loop_exit *) *slot;
|
struct loop_exit *exit = (struct loop_exit *) *slot;
|
unsigned n = 0;
|
unsigned n = 0;
|
edge e = exit->e;
|
edge e = exit->e;
|
|
|
for (; exit != NULL; exit = exit->next_e)
|
for (; exit != NULL; exit = exit->next_e)
|
n++;
|
n++;
|
|
|
fprintf ((FILE*) file, "Edge %d->%d exits %u loops\n",
|
fprintf ((FILE*) file, "Edge %d->%d exits %u loops\n",
|
e->src->index, e->dest->index, n);
|
e->src->index, e->dest->index, n);
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Dumps the recorded exits of loops to FILE. */
|
/* Dumps the recorded exits of loops to FILE. */
|
|
|
extern void dump_recorded_exits (FILE *);
|
extern void dump_recorded_exits (FILE *);
|
void
|
void
|
dump_recorded_exits (FILE *file)
|
dump_recorded_exits (FILE *file)
|
{
|
{
|
if (!current_loops->exits)
|
if (!current_loops->exits)
|
return;
|
return;
|
htab_traverse (current_loops->exits, dump_recorded_exit, file);
|
htab_traverse (current_loops->exits, dump_recorded_exit, file);
|
}
|
}
|
|
|
/* Releases lists of loop exits. */
|
/* Releases lists of loop exits. */
|
|
|
void
|
void
|
release_recorded_exits (void)
|
release_recorded_exits (void)
|
{
|
{
|
gcc_assert (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS));
|
gcc_assert (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS));
|
htab_delete (current_loops->exits);
|
htab_delete (current_loops->exits);
|
current_loops->exits = NULL;
|
current_loops->exits = NULL;
|
loops_state_clear (LOOPS_HAVE_RECORDED_EXITS);
|
loops_state_clear (LOOPS_HAVE_RECORDED_EXITS);
|
}
|
}
|
|
|
/* Returns the list of the exit edges of a LOOP. */
|
/* Returns the list of the exit edges of a LOOP. */
|
|
|
VEC (edge, heap) *
|
VEC (edge, heap) *
|
get_loop_exit_edges (const struct loop *loop)
|
get_loop_exit_edges (const struct loop *loop)
|
{
|
{
|
VEC (edge, heap) *edges = NULL;
|
VEC (edge, heap) *edges = NULL;
|
edge e;
|
edge e;
|
unsigned i;
|
unsigned i;
|
basic_block *body;
|
basic_block *body;
|
edge_iterator ei;
|
edge_iterator ei;
|
struct loop_exit *exit;
|
struct loop_exit *exit;
|
|
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
|
|
/* If we maintain the lists of exits, use them. Otherwise we must
|
/* If we maintain the lists of exits, use them. Otherwise we must
|
scan the body of the loop. */
|
scan the body of the loop. */
|
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
{
|
{
|
for (exit = loop->exits->next; exit->e; exit = exit->next)
|
for (exit = loop->exits->next; exit->e; exit = exit->next)
|
VEC_safe_push (edge, heap, edges, exit->e);
|
VEC_safe_push (edge, heap, edges, exit->e);
|
}
|
}
|
else
|
else
|
{
|
{
|
body = get_loop_body (loop);
|
body = get_loop_body (loop);
|
for (i = 0; i < loop->num_nodes; i++)
|
for (i = 0; i < loop->num_nodes; i++)
|
FOR_EACH_EDGE (e, ei, body[i]->succs)
|
FOR_EACH_EDGE (e, ei, body[i]->succs)
|
{
|
{
|
if (!flow_bb_inside_loop_p (loop, e->dest))
|
if (!flow_bb_inside_loop_p (loop, e->dest))
|
VEC_safe_push (edge, heap, edges, e);
|
VEC_safe_push (edge, heap, edges, e);
|
}
|
}
|
free (body);
|
free (body);
|
}
|
}
|
|
|
return edges;
|
return edges;
|
}
|
}
|
|
|
/* Counts the number of conditional branches inside LOOP. */
|
/* Counts the number of conditional branches inside LOOP. */
|
|
|
unsigned
|
unsigned
|
num_loop_branches (const struct loop *loop)
|
num_loop_branches (const struct loop *loop)
|
{
|
{
|
unsigned i, n;
|
unsigned i, n;
|
basic_block * body;
|
basic_block * body;
|
|
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
gcc_assert (loop->latch != EXIT_BLOCK_PTR);
|
|
|
body = get_loop_body (loop);
|
body = get_loop_body (loop);
|
n = 0;
|
n = 0;
|
for (i = 0; i < loop->num_nodes; i++)
|
for (i = 0; i < loop->num_nodes; i++)
|
if (EDGE_COUNT (body[i]->succs) >= 2)
|
if (EDGE_COUNT (body[i]->succs) >= 2)
|
n++;
|
n++;
|
free (body);
|
free (body);
|
|
|
return n;
|
return n;
|
}
|
}
|
|
|
/* Adds basic block BB to LOOP. */
|
/* Adds basic block BB to LOOP. */
|
void
|
void
|
add_bb_to_loop (basic_block bb, struct loop *loop)
|
add_bb_to_loop (basic_block bb, struct loop *loop)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
loop_p ploop;
|
loop_p ploop;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
gcc_assert (bb->loop_father == NULL);
|
gcc_assert (bb->loop_father == NULL);
|
bb->loop_father = loop;
|
bb->loop_father = loop;
|
bb->loop_depth = loop_depth (loop);
|
bb->loop_depth = loop_depth (loop);
|
loop->num_nodes++;
|
loop->num_nodes++;
|
for (i = 0; VEC_iterate (loop_p, loop->superloops, i, ploop); i++)
|
for (i = 0; VEC_iterate (loop_p, loop->superloops, i, ploop); i++)
|
ploop->num_nodes++;
|
ploop->num_nodes++;
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
{
|
{
|
rescan_loop_exit (e, true, false);
|
rescan_loop_exit (e, true, false);
|
}
|
}
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
{
|
{
|
rescan_loop_exit (e, true, false);
|
rescan_loop_exit (e, true, false);
|
}
|
}
|
}
|
}
|
|
|
/* Remove basic block BB from loops. */
|
/* Remove basic block BB from loops. */
|
void
|
void
|
remove_bb_from_loops (basic_block bb)
|
remove_bb_from_loops (basic_block bb)
|
{
|
{
|
int i;
|
int i;
|
struct loop *loop = bb->loop_father;
|
struct loop *loop = bb->loop_father;
|
loop_p ploop;
|
loop_p ploop;
|
edge_iterator ei;
|
edge_iterator ei;
|
edge e;
|
edge e;
|
|
|
gcc_assert (loop != NULL);
|
gcc_assert (loop != NULL);
|
loop->num_nodes--;
|
loop->num_nodes--;
|
for (i = 0; VEC_iterate (loop_p, loop->superloops, i, ploop); i++)
|
for (i = 0; VEC_iterate (loop_p, loop->superloops, i, ploop); i++)
|
ploop->num_nodes--;
|
ploop->num_nodes--;
|
bb->loop_father = NULL;
|
bb->loop_father = NULL;
|
bb->loop_depth = 0;
|
bb->loop_depth = 0;
|
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
{
|
{
|
rescan_loop_exit (e, false, true);
|
rescan_loop_exit (e, false, true);
|
}
|
}
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
{
|
{
|
rescan_loop_exit (e, false, true);
|
rescan_loop_exit (e, false, true);
|
}
|
}
|
}
|
}
|
|
|
/* Finds nearest common ancestor in loop tree for given loops. */
|
/* Finds nearest common ancestor in loop tree for given loops. */
|
struct loop *
|
struct loop *
|
find_common_loop (struct loop *loop_s, struct loop *loop_d)
|
find_common_loop (struct loop *loop_s, struct loop *loop_d)
|
{
|
{
|
unsigned sdepth, ddepth;
|
unsigned sdepth, ddepth;
|
|
|
if (!loop_s) return loop_d;
|
if (!loop_s) return loop_d;
|
if (!loop_d) return loop_s;
|
if (!loop_d) return loop_s;
|
|
|
sdepth = loop_depth (loop_s);
|
sdepth = loop_depth (loop_s);
|
ddepth = loop_depth (loop_d);
|
ddepth = loop_depth (loop_d);
|
|
|
if (sdepth < ddepth)
|
if (sdepth < ddepth)
|
loop_d = VEC_index (loop_p, loop_d->superloops, sdepth);
|
loop_d = VEC_index (loop_p, loop_d->superloops, sdepth);
|
else if (sdepth > ddepth)
|
else if (sdepth > ddepth)
|
loop_s = VEC_index (loop_p, loop_s->superloops, ddepth);
|
loop_s = VEC_index (loop_p, loop_s->superloops, ddepth);
|
|
|
while (loop_s != loop_d)
|
while (loop_s != loop_d)
|
{
|
{
|
loop_s = loop_outer (loop_s);
|
loop_s = loop_outer (loop_s);
|
loop_d = loop_outer (loop_d);
|
loop_d = loop_outer (loop_d);
|
}
|
}
|
return loop_s;
|
return loop_s;
|
}
|
}
|
|
|
/* Removes LOOP from structures and frees its data. */
|
/* Removes LOOP from structures and frees its data. */
|
|
|
void
|
void
|
delete_loop (struct loop *loop)
|
delete_loop (struct loop *loop)
|
{
|
{
|
/* Remove the loop from structure. */
|
/* Remove the loop from structure. */
|
flow_loop_tree_node_remove (loop);
|
flow_loop_tree_node_remove (loop);
|
|
|
/* Remove loop from loops array. */
|
/* Remove loop from loops array. */
|
VEC_replace (loop_p, current_loops->larray, loop->num, NULL);
|
VEC_replace (loop_p, current_loops->larray, loop->num, NULL);
|
|
|
/* Free loop data. */
|
/* Free loop data. */
|
flow_loop_free (loop);
|
flow_loop_free (loop);
|
}
|
}
|
|
|
/* Cancels the LOOP; it must be innermost one. */
|
/* Cancels the LOOP; it must be innermost one. */
|
|
|
static void
|
static void
|
cancel_loop (struct loop *loop)
|
cancel_loop (struct loop *loop)
|
{
|
{
|
basic_block *bbs;
|
basic_block *bbs;
|
unsigned i;
|
unsigned i;
|
struct loop *outer = loop_outer (loop);
|
struct loop *outer = loop_outer (loop);
|
|
|
gcc_assert (!loop->inner);
|
gcc_assert (!loop->inner);
|
|
|
/* Move blocks up one level (they should be removed as soon as possible). */
|
/* Move blocks up one level (they should be removed as soon as possible). */
|
bbs = get_loop_body (loop);
|
bbs = get_loop_body (loop);
|
for (i = 0; i < loop->num_nodes; i++)
|
for (i = 0; i < loop->num_nodes; i++)
|
bbs[i]->loop_father = outer;
|
bbs[i]->loop_father = outer;
|
|
|
delete_loop (loop);
|
delete_loop (loop);
|
}
|
}
|
|
|
/* Cancels LOOP and all its subloops. */
|
/* Cancels LOOP and all its subloops. */
|
void
|
void
|
cancel_loop_tree (struct loop *loop)
|
cancel_loop_tree (struct loop *loop)
|
{
|
{
|
while (loop->inner)
|
while (loop->inner)
|
cancel_loop_tree (loop->inner);
|
cancel_loop_tree (loop->inner);
|
cancel_loop (loop);
|
cancel_loop (loop);
|
}
|
}
|
|
|
/* Checks that information about loops is correct
|
/* Checks that information about loops is correct
|
-- sizes of loops are all right
|
-- sizes of loops are all right
|
-- results of get_loop_body really belong to the loop
|
-- results of get_loop_body really belong to the loop
|
-- loop header have just single entry edge and single latch edge
|
-- loop header have just single entry edge and single latch edge
|
-- loop latches have only single successor that is header of their loop
|
-- loop latches have only single successor that is header of their loop
|
-- irreducible loops are correctly marked
|
-- irreducible loops are correctly marked
|
*/
|
*/
|
void
|
void
|
verify_loop_structure (void)
|
verify_loop_structure (void)
|
{
|
{
|
unsigned *sizes, i, j;
|
unsigned *sizes, i, j;
|
sbitmap irreds;
|
sbitmap irreds;
|
basic_block *bbs, bb;
|
basic_block *bbs, bb;
|
struct loop *loop;
|
struct loop *loop;
|
int err = 0;
|
int err = 0;
|
edge e;
|
edge e;
|
unsigned num = number_of_loops ();
|
unsigned num = number_of_loops ();
|
loop_iterator li;
|
loop_iterator li;
|
struct loop_exit *exit, *mexit;
|
struct loop_exit *exit, *mexit;
|
|
|
/* Check sizes. */
|
/* Check sizes. */
|
sizes = XCNEWVEC (unsigned, num);
|
sizes = XCNEWVEC (unsigned, num);
|
sizes[0] = 2;
|
sizes[0] = 2;
|
|
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
for (loop = bb->loop_father; loop; loop = loop_outer (loop))
|
for (loop = bb->loop_father; loop; loop = loop_outer (loop))
|
sizes[loop->num]++;
|
sizes[loop->num]++;
|
|
|
FOR_EACH_LOOP (li, loop, LI_INCLUDE_ROOT)
|
FOR_EACH_LOOP (li, loop, LI_INCLUDE_ROOT)
|
{
|
{
|
i = loop->num;
|
i = loop->num;
|
|
|
if (loop->num_nodes != sizes[i])
|
if (loop->num_nodes != sizes[i])
|
{
|
{
|
error ("size of loop %d should be %d, not %d",
|
error ("size of loop %d should be %d, not %d",
|
i, sizes[i], loop->num_nodes);
|
i, sizes[i], loop->num_nodes);
|
err = 1;
|
err = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Check get_loop_body. */
|
/* Check get_loop_body. */
|
FOR_EACH_LOOP (li, loop, 0)
|
FOR_EACH_LOOP (li, loop, 0)
|
{
|
{
|
bbs = get_loop_body (loop);
|
bbs = get_loop_body (loop);
|
|
|
for (j = 0; j < loop->num_nodes; j++)
|
for (j = 0; j < loop->num_nodes; j++)
|
if (!flow_bb_inside_loop_p (loop, bbs[j]))
|
if (!flow_bb_inside_loop_p (loop, bbs[j]))
|
{
|
{
|
error ("bb %d do not belong to loop %d",
|
error ("bb %d do not belong to loop %d",
|
bbs[j]->index, loop->num);
|
bbs[j]->index, loop->num);
|
err = 1;
|
err = 1;
|
}
|
}
|
free (bbs);
|
free (bbs);
|
}
|
}
|
|
|
/* Check headers and latches. */
|
/* Check headers and latches. */
|
FOR_EACH_LOOP (li, loop, 0)
|
FOR_EACH_LOOP (li, loop, 0)
|
{
|
{
|
i = loop->num;
|
i = loop->num;
|
|
|
if (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS)
|
if (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS)
|
&& EDGE_COUNT (loop->header->preds) != 2)
|
&& EDGE_COUNT (loop->header->preds) != 2)
|
{
|
{
|
error ("loop %d's header does not have exactly 2 entries", i);
|
error ("loop %d's header does not have exactly 2 entries", i);
|
err = 1;
|
err = 1;
|
}
|
}
|
if (loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES))
|
if (loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES))
|
{
|
{
|
if (!single_succ_p (loop->latch))
|
if (!single_succ_p (loop->latch))
|
{
|
{
|
error ("loop %d's latch does not have exactly 1 successor", i);
|
error ("loop %d's latch does not have exactly 1 successor", i);
|
err = 1;
|
err = 1;
|
}
|
}
|
if (single_succ (loop->latch) != loop->header)
|
if (single_succ (loop->latch) != loop->header)
|
{
|
{
|
error ("loop %d's latch does not have header as successor", i);
|
error ("loop %d's latch does not have header as successor", i);
|
err = 1;
|
err = 1;
|
}
|
}
|
if (loop->latch->loop_father != loop)
|
if (loop->latch->loop_father != loop)
|
{
|
{
|
error ("loop %d's latch does not belong directly to it", i);
|
error ("loop %d's latch does not belong directly to it", i);
|
err = 1;
|
err = 1;
|
}
|
}
|
}
|
}
|
if (loop->header->loop_father != loop)
|
if (loop->header->loop_father != loop)
|
{
|
{
|
error ("loop %d's header does not belong directly to it", i);
|
error ("loop %d's header does not belong directly to it", i);
|
err = 1;
|
err = 1;
|
}
|
}
|
if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
|
if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
|
&& (loop_latch_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP))
|
&& (loop_latch_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP))
|
{
|
{
|
error ("loop %d's latch is marked as part of irreducible region", i);
|
error ("loop %d's latch is marked as part of irreducible region", i);
|
err = 1;
|
err = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Check irreducible loops. */
|
/* Check irreducible loops. */
|
if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS))
|
if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS))
|
{
|
{
|
/* Record old info. */
|
/* Record old info. */
|
irreds = sbitmap_alloc (last_basic_block);
|
irreds = sbitmap_alloc (last_basic_block);
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
if (bb->flags & BB_IRREDUCIBLE_LOOP)
|
if (bb->flags & BB_IRREDUCIBLE_LOOP)
|
SET_BIT (irreds, bb->index);
|
SET_BIT (irreds, bb->index);
|
else
|
else
|
RESET_BIT (irreds, bb->index);
|
RESET_BIT (irreds, bb->index);
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
if (e->flags & EDGE_IRREDUCIBLE_LOOP)
|
if (e->flags & EDGE_IRREDUCIBLE_LOOP)
|
e->flags |= EDGE_ALL_FLAGS + 1;
|
e->flags |= EDGE_ALL_FLAGS + 1;
|
}
|
}
|
|
|
/* Recount it. */
|
/* Recount it. */
|
mark_irreducible_loops ();
|
mark_irreducible_loops ();
|
|
|
/* Compare. */
|
/* Compare. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
if ((bb->flags & BB_IRREDUCIBLE_LOOP)
|
if ((bb->flags & BB_IRREDUCIBLE_LOOP)
|
&& !TEST_BIT (irreds, bb->index))
|
&& !TEST_BIT (irreds, bb->index))
|
{
|
{
|
error ("basic block %d should be marked irreducible", bb->index);
|
error ("basic block %d should be marked irreducible", bb->index);
|
err = 1;
|
err = 1;
|
}
|
}
|
else if (!(bb->flags & BB_IRREDUCIBLE_LOOP)
|
else if (!(bb->flags & BB_IRREDUCIBLE_LOOP)
|
&& TEST_BIT (irreds, bb->index))
|
&& TEST_BIT (irreds, bb->index))
|
{
|
{
|
error ("basic block %d should not be marked irreducible", bb->index);
|
error ("basic block %d should not be marked irreducible", bb->index);
|
err = 1;
|
err = 1;
|
}
|
}
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
{
|
{
|
if ((e->flags & EDGE_IRREDUCIBLE_LOOP)
|
if ((e->flags & EDGE_IRREDUCIBLE_LOOP)
|
&& !(e->flags & (EDGE_ALL_FLAGS + 1)))
|
&& !(e->flags & (EDGE_ALL_FLAGS + 1)))
|
{
|
{
|
error ("edge from %d to %d should be marked irreducible",
|
error ("edge from %d to %d should be marked irreducible",
|
e->src->index, e->dest->index);
|
e->src->index, e->dest->index);
|
err = 1;
|
err = 1;
|
}
|
}
|
else if (!(e->flags & EDGE_IRREDUCIBLE_LOOP)
|
else if (!(e->flags & EDGE_IRREDUCIBLE_LOOP)
|
&& (e->flags & (EDGE_ALL_FLAGS + 1)))
|
&& (e->flags & (EDGE_ALL_FLAGS + 1)))
|
{
|
{
|
error ("edge from %d to %d should not be marked irreducible",
|
error ("edge from %d to %d should not be marked irreducible",
|
e->src->index, e->dest->index);
|
e->src->index, e->dest->index);
|
err = 1;
|
err = 1;
|
}
|
}
|
e->flags &= ~(EDGE_ALL_FLAGS + 1);
|
e->flags &= ~(EDGE_ALL_FLAGS + 1);
|
}
|
}
|
}
|
}
|
free (irreds);
|
free (irreds);
|
}
|
}
|
|
|
/* Check the recorded loop exits. */
|
/* Check the recorded loop exits. */
|
FOR_EACH_LOOP (li, loop, 0)
|
FOR_EACH_LOOP (li, loop, 0)
|
{
|
{
|
if (!loop->exits || loop->exits->e != NULL)
|
if (!loop->exits || loop->exits->e != NULL)
|
{
|
{
|
error ("corrupted head of the exits list of loop %d",
|
error ("corrupted head of the exits list of loop %d",
|
loop->num);
|
loop->num);
|
err = 1;
|
err = 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Check that the list forms a cycle, and all elements except
|
/* Check that the list forms a cycle, and all elements except
|
for the head are nonnull. */
|
for the head are nonnull. */
|
for (mexit = loop->exits, exit = mexit->next, i = 0;
|
for (mexit = loop->exits, exit = mexit->next, i = 0;
|
exit->e && exit != mexit;
|
exit->e && exit != mexit;
|
exit = exit->next)
|
exit = exit->next)
|
{
|
{
|
if (i++ & 1)
|
if (i++ & 1)
|
mexit = mexit->next;
|
mexit = mexit->next;
|
}
|
}
|
|
|
if (exit != loop->exits)
|
if (exit != loop->exits)
|
{
|
{
|
error ("corrupted exits list of loop %d", loop->num);
|
error ("corrupted exits list of loop %d", loop->num);
|
err = 1;
|
err = 1;
|
}
|
}
|
}
|
}
|
|
|
if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
{
|
{
|
if (loop->exits->next != loop->exits)
|
if (loop->exits->next != loop->exits)
|
{
|
{
|
error ("nonempty exits list of loop %d, but exits are not recorded",
|
error ("nonempty exits list of loop %d, but exits are not recorded",
|
loop->num);
|
loop->num);
|
err = 1;
|
err = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
{
|
{
|
unsigned n_exits = 0, eloops;
|
unsigned n_exits = 0, eloops;
|
|
|
memset (sizes, 0, sizeof (unsigned) * num);
|
memset (sizes, 0, sizeof (unsigned) * num);
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
edge_iterator ei;
|
edge_iterator ei;
|
if (bb->loop_father == current_loops->tree_root)
|
if (bb->loop_father == current_loops->tree_root)
|
continue;
|
continue;
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
{
|
{
|
if (flow_bb_inside_loop_p (bb->loop_father, e->dest))
|
if (flow_bb_inside_loop_p (bb->loop_father, e->dest))
|
continue;
|
continue;
|
|
|
n_exits++;
|
n_exits++;
|
exit = get_exit_descriptions (e);
|
exit = get_exit_descriptions (e);
|
if (!exit)
|
if (!exit)
|
{
|
{
|
error ("Exit %d->%d not recorded",
|
error ("Exit %d->%d not recorded",
|
e->src->index, e->dest->index);
|
e->src->index, e->dest->index);
|
err = 1;
|
err = 1;
|
}
|
}
|
eloops = 0;
|
eloops = 0;
|
for (; exit; exit = exit->next_e)
|
for (; exit; exit = exit->next_e)
|
eloops++;
|
eloops++;
|
|
|
for (loop = bb->loop_father;
|
for (loop = bb->loop_father;
|
loop != e->dest->loop_father;
|
loop != e->dest->loop_father;
|
loop = loop_outer (loop))
|
loop = loop_outer (loop))
|
{
|
{
|
eloops--;
|
eloops--;
|
sizes[loop->num]++;
|
sizes[loop->num]++;
|
}
|
}
|
|
|
if (eloops != 0)
|
if (eloops != 0)
|
{
|
{
|
error ("Wrong list of exited loops for edge %d->%d",
|
error ("Wrong list of exited loops for edge %d->%d",
|
e->src->index, e->dest->index);
|
e->src->index, e->dest->index);
|
err = 1;
|
err = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (n_exits != htab_elements (current_loops->exits))
|
if (n_exits != htab_elements (current_loops->exits))
|
{
|
{
|
error ("Too many loop exits recorded");
|
error ("Too many loop exits recorded");
|
err = 1;
|
err = 1;
|
}
|
}
|
|
|
FOR_EACH_LOOP (li, loop, 0)
|
FOR_EACH_LOOP (li, loop, 0)
|
{
|
{
|
eloops = 0;
|
eloops = 0;
|
for (exit = loop->exits->next; exit->e; exit = exit->next)
|
for (exit = loop->exits->next; exit->e; exit = exit->next)
|
eloops++;
|
eloops++;
|
if (eloops != sizes[loop->num])
|
if (eloops != sizes[loop->num])
|
{
|
{
|
error ("%d exits recorded for loop %d (having %d exits)",
|
error ("%d exits recorded for loop %d (having %d exits)",
|
eloops, loop->num, sizes[loop->num]);
|
eloops, loop->num, sizes[loop->num]);
|
err = 1;
|
err = 1;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
gcc_assert (!err);
|
gcc_assert (!err);
|
|
|
free (sizes);
|
free (sizes);
|
}
|
}
|
|
|
/* Returns latch edge of LOOP. */
|
/* Returns latch edge of LOOP. */
|
edge
|
edge
|
loop_latch_edge (const struct loop *loop)
|
loop_latch_edge (const struct loop *loop)
|
{
|
{
|
return find_edge (loop->latch, loop->header);
|
return find_edge (loop->latch, loop->header);
|
}
|
}
|
|
|
/* Returns preheader edge of LOOP. */
|
/* Returns preheader edge of LOOP. */
|
edge
|
edge
|
loop_preheader_edge (const struct loop *loop)
|
loop_preheader_edge (const struct loop *loop)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
gcc_assert (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS));
|
gcc_assert (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS));
|
|
|
FOR_EACH_EDGE (e, ei, loop->header->preds)
|
FOR_EACH_EDGE (e, ei, loop->header->preds)
|
if (e->src != loop->latch)
|
if (e->src != loop->latch)
|
break;
|
break;
|
|
|
return e;
|
return e;
|
}
|
}
|
|
|
/* Returns true if E is an exit of LOOP. */
|
/* Returns true if E is an exit of LOOP. */
|
|
|
bool
|
bool
|
loop_exit_edge_p (const struct loop *loop, const_edge e)
|
loop_exit_edge_p (const struct loop *loop, const_edge e)
|
{
|
{
|
return (flow_bb_inside_loop_p (loop, e->src)
|
return (flow_bb_inside_loop_p (loop, e->src)
|
&& !flow_bb_inside_loop_p (loop, e->dest));
|
&& !flow_bb_inside_loop_p (loop, e->dest));
|
}
|
}
|
|
|
/* Returns the single exit edge of LOOP, or NULL if LOOP has either no exit
|
/* Returns the single exit edge of LOOP, or NULL if LOOP has either no exit
|
or more than one exit. If loops do not have the exits recorded, NULL
|
or more than one exit. If loops do not have the exits recorded, NULL
|
is returned always. */
|
is returned always. */
|
|
|
edge
|
edge
|
single_exit (const struct loop *loop)
|
single_exit (const struct loop *loop)
|
{
|
{
|
struct loop_exit *exit = loop->exits->next;
|
struct loop_exit *exit = loop->exits->next;
|
|
|
if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
|
return NULL;
|
return NULL;
|
|
|
if (exit->e && exit->next == loop->exits)
|
if (exit->e && exit->next == loop->exits)
|
return exit->e;
|
return exit->e;
|
else
|
else
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/* Returns true when BB has an edge exiting LOOP. */
|
/* Returns true when BB has an edge exiting LOOP. */
|
|
|
bool
|
bool
|
is_loop_exit (struct loop *loop, basic_block bb)
|
is_loop_exit (struct loop *loop, basic_block bb)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
if (loop_exit_edge_p (loop, e))
|
if (loop_exit_edge_p (loop, e))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
