1*38fd1498Szrj /* Natural loop discovery code for GNU compiler.
2*38fd1498Szrj Copyright (C) 2000-2018 Free Software Foundation, Inc.
3*38fd1498Szrj
4*38fd1498Szrj This file is part of GCC.
5*38fd1498Szrj
6*38fd1498Szrj GCC is free software; you can redistribute it and/or modify it under
7*38fd1498Szrj the terms of the GNU General Public License as published by the Free
8*38fd1498Szrj Software Foundation; either version 3, or (at your option) any later
9*38fd1498Szrj version.
10*38fd1498Szrj
11*38fd1498Szrj GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12*38fd1498Szrj WARRANTY; without even the implied warranty of MERCHANTABILITY or
13*38fd1498Szrj FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14*38fd1498Szrj for more details.
15*38fd1498Szrj
16*38fd1498Szrj You should have received a copy of the GNU General Public License
17*38fd1498Szrj along with GCC; see the file COPYING3. If not see
18*38fd1498Szrj <http://www.gnu.org/licenses/>. */
19*38fd1498Szrj
20*38fd1498Szrj #include "config.h"
21*38fd1498Szrj #include "system.h"
22*38fd1498Szrj #include "coretypes.h"
23*38fd1498Szrj #include "backend.h"
24*38fd1498Szrj #include "rtl.h"
25*38fd1498Szrj #include "tree.h"
26*38fd1498Szrj #include "gimple.h"
27*38fd1498Szrj #include "cfghooks.h"
28*38fd1498Szrj #include "gimple-ssa.h"
29*38fd1498Szrj #include "diagnostic-core.h"
30*38fd1498Szrj #include "cfganal.h"
31*38fd1498Szrj #include "cfgloop.h"
32*38fd1498Szrj #include "gimple-iterator.h"
33*38fd1498Szrj #include "dumpfile.h"
34*38fd1498Szrj
35*38fd1498Szrj static void flow_loops_cfg_dump (FILE *);
36*38fd1498Szrj
37*38fd1498Szrj /* Dump loop related CFG information. */
38*38fd1498Szrj
39*38fd1498Szrj static void
flow_loops_cfg_dump(FILE * file)40*38fd1498Szrj flow_loops_cfg_dump (FILE *file)
41*38fd1498Szrj {
42*38fd1498Szrj basic_block bb;
43*38fd1498Szrj
44*38fd1498Szrj if (!file)
45*38fd1498Szrj return;
46*38fd1498Szrj
47*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
48*38fd1498Szrj {
49*38fd1498Szrj edge succ;
50*38fd1498Szrj edge_iterator ei;
51*38fd1498Szrj
52*38fd1498Szrj fprintf (file, ";; %d succs { ", bb->index);
53*38fd1498Szrj FOR_EACH_EDGE (succ, ei, bb->succs)
54*38fd1498Szrj fprintf (file, "%d ", succ->dest->index);
55*38fd1498Szrj fprintf (file, "}\n");
56*38fd1498Szrj }
57*38fd1498Szrj }
58*38fd1498Szrj
59*38fd1498Szrj /* Return nonzero if the nodes of LOOP are a subset of OUTER. */
60*38fd1498Szrj
61*38fd1498Szrj bool
flow_loop_nested_p(const struct loop * outer,const struct loop * loop)62*38fd1498Szrj flow_loop_nested_p (const struct loop *outer, const struct loop *loop)
63*38fd1498Szrj {
64*38fd1498Szrj unsigned odepth = loop_depth (outer);
65*38fd1498Szrj
66*38fd1498Szrj return (loop_depth (loop) > odepth
67*38fd1498Szrj && (*loop->superloops)[odepth] == outer);
68*38fd1498Szrj }
69*38fd1498Szrj
70*38fd1498Szrj /* Returns the loop such that LOOP is nested DEPTH (indexed from zero)
71*38fd1498Szrj loops within LOOP. */
72*38fd1498Szrj
73*38fd1498Szrj struct loop *
superloop_at_depth(struct loop * loop,unsigned depth)74*38fd1498Szrj superloop_at_depth (struct loop *loop, unsigned depth)
75*38fd1498Szrj {
76*38fd1498Szrj unsigned ldepth = loop_depth (loop);
77*38fd1498Szrj
78*38fd1498Szrj gcc_assert (depth <= ldepth);
79*38fd1498Szrj
80*38fd1498Szrj if (depth == ldepth)
81*38fd1498Szrj return loop;
82*38fd1498Szrj
83*38fd1498Szrj return (*loop->superloops)[depth];
84*38fd1498Szrj }
85*38fd1498Szrj
86*38fd1498Szrj /* Returns the list of the latch edges of LOOP. */
87*38fd1498Szrj
88*38fd1498Szrj static vec<edge>
get_loop_latch_edges(const struct loop * loop)89*38fd1498Szrj get_loop_latch_edges (const struct loop *loop)
90*38fd1498Szrj {
91*38fd1498Szrj edge_iterator ei;
92*38fd1498Szrj edge e;
93*38fd1498Szrj vec<edge> ret = vNULL;
94*38fd1498Szrj
95*38fd1498Szrj FOR_EACH_EDGE (e, ei, loop->header->preds)
96*38fd1498Szrj {
97*38fd1498Szrj if (dominated_by_p (CDI_DOMINATORS, e->src, loop->header))
98*38fd1498Szrj ret.safe_push (e);
99*38fd1498Szrj }
100*38fd1498Szrj
101*38fd1498Szrj return ret;
102*38fd1498Szrj }
103*38fd1498Szrj
104*38fd1498Szrj /* Dump the loop information specified by LOOP to the stream FILE
105*38fd1498Szrj using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
106*38fd1498Szrj
107*38fd1498Szrj void
flow_loop_dump(const struct loop * loop,FILE * file,void (* loop_dump_aux)(const struct loop *,FILE *,int),int verbose)108*38fd1498Szrj flow_loop_dump (const struct loop *loop, FILE *file,
109*38fd1498Szrj void (*loop_dump_aux) (const struct loop *, FILE *, int),
110*38fd1498Szrj int verbose)
111*38fd1498Szrj {
112*38fd1498Szrj basic_block *bbs;
113*38fd1498Szrj unsigned i;
114*38fd1498Szrj vec<edge> latches;
115*38fd1498Szrj edge e;
116*38fd1498Szrj
117*38fd1498Szrj if (! loop || ! loop->header)
118*38fd1498Szrj return;
119*38fd1498Szrj
120*38fd1498Szrj fprintf (file, ";;\n;; Loop %d\n", loop->num);
121*38fd1498Szrj
122*38fd1498Szrj fprintf (file, ";; header %d, ", loop->header->index);
123*38fd1498Szrj if (loop->latch)
124*38fd1498Szrj fprintf (file, "latch %d\n", loop->latch->index);
125*38fd1498Szrj else
126*38fd1498Szrj {
127*38fd1498Szrj fprintf (file, "multiple latches:");
128*38fd1498Szrj latches = get_loop_latch_edges (loop);
129*38fd1498Szrj FOR_EACH_VEC_ELT (latches, i, e)
130*38fd1498Szrj fprintf (file, " %d", e->src->index);
131*38fd1498Szrj latches.release ();
132*38fd1498Szrj fprintf (file, "\n");
133*38fd1498Szrj }
134*38fd1498Szrj
135*38fd1498Szrj fprintf (file, ";; depth %d, outer %ld\n",
136*38fd1498Szrj loop_depth (loop), (long) (loop_outer (loop)
137*38fd1498Szrj ? loop_outer (loop)->num : -1));
138*38fd1498Szrj
139*38fd1498Szrj if (loop->latch)
140*38fd1498Szrj {
141*38fd1498Szrj bool read_profile_p;
142*38fd1498Szrj gcov_type nit = expected_loop_iterations_unbounded (loop, &read_profile_p);
143*38fd1498Szrj if (read_profile_p && !loop->any_estimate)
144*38fd1498Szrj fprintf (file, ";; profile-based iteration count: %" PRIu64 "\n",
145*38fd1498Szrj (uint64_t) nit);
146*38fd1498Szrj }
147*38fd1498Szrj
148*38fd1498Szrj fprintf (file, ";; nodes:");
149*38fd1498Szrj bbs = get_loop_body (loop);
150*38fd1498Szrj for (i = 0; i < loop->num_nodes; i++)
151*38fd1498Szrj fprintf (file, " %d", bbs[i]->index);
152*38fd1498Szrj free (bbs);
153*38fd1498Szrj fprintf (file, "\n");
154*38fd1498Szrj
155*38fd1498Szrj if (loop_dump_aux)
156*38fd1498Szrj loop_dump_aux (loop, file, verbose);
157*38fd1498Szrj }
158*38fd1498Szrj
159*38fd1498Szrj /* Dump the loop information about loops to the stream FILE,
160*38fd1498Szrj using auxiliary dump callback function LOOP_DUMP_AUX if non null. */
161*38fd1498Szrj
162*38fd1498Szrj void
flow_loops_dump(FILE * file,void (* loop_dump_aux)(const struct loop *,FILE *,int),int verbose)163*38fd1498Szrj flow_loops_dump (FILE *file, void (*loop_dump_aux) (const struct loop *, FILE *, int), int verbose)
164*38fd1498Szrj {
165*38fd1498Szrj struct loop *loop;
166*38fd1498Szrj
167*38fd1498Szrj if (!current_loops || ! file)
168*38fd1498Szrj return;
169*38fd1498Szrj
170*38fd1498Szrj fprintf (file, ";; %d loops found\n", number_of_loops (cfun));
171*38fd1498Szrj
172*38fd1498Szrj FOR_EACH_LOOP (loop, LI_INCLUDE_ROOT)
173*38fd1498Szrj {
174*38fd1498Szrj flow_loop_dump (loop, file, loop_dump_aux, verbose);
175*38fd1498Szrj }
176*38fd1498Szrj
177*38fd1498Szrj if (verbose)
178*38fd1498Szrj flow_loops_cfg_dump (file);
179*38fd1498Szrj }
180*38fd1498Szrj
181*38fd1498Szrj /* Free data allocated for LOOP. */
182*38fd1498Szrj
183*38fd1498Szrj void
flow_loop_free(struct loop * loop)184*38fd1498Szrj flow_loop_free (struct loop *loop)
185*38fd1498Szrj {
186*38fd1498Szrj struct loop_exit *exit, *next;
187*38fd1498Szrj
188*38fd1498Szrj vec_free (loop->superloops);
189*38fd1498Szrj
190*38fd1498Szrj /* Break the list of the loop exit records. They will be freed when the
191*38fd1498Szrj corresponding edge is rescanned or removed, and this avoids
192*38fd1498Szrj accessing the (already released) head of the list stored in the
193*38fd1498Szrj loop structure. */
194*38fd1498Szrj for (exit = loop->exits->next; exit != loop->exits; exit = next)
195*38fd1498Szrj {
196*38fd1498Szrj next = exit->next;
197*38fd1498Szrj exit->next = exit;
198*38fd1498Szrj exit->prev = exit;
199*38fd1498Szrj }
200*38fd1498Szrj
201*38fd1498Szrj ggc_free (loop->exits);
202*38fd1498Szrj ggc_free (loop);
203*38fd1498Szrj }
204*38fd1498Szrj
205*38fd1498Szrj /* Free all the memory allocated for LOOPS. */
206*38fd1498Szrj
207*38fd1498Szrj void
flow_loops_free(struct loops * loops)208*38fd1498Szrj flow_loops_free (struct loops *loops)
209*38fd1498Szrj {
210*38fd1498Szrj if (loops->larray)
211*38fd1498Szrj {
212*38fd1498Szrj unsigned i;
213*38fd1498Szrj loop_p loop;
214*38fd1498Szrj
215*38fd1498Szrj /* Free the loop descriptors. */
216*38fd1498Szrj FOR_EACH_VEC_SAFE_ELT (loops->larray, i, loop)
217*38fd1498Szrj {
218*38fd1498Szrj if (!loop)
219*38fd1498Szrj continue;
220*38fd1498Szrj
221*38fd1498Szrj flow_loop_free (loop);
222*38fd1498Szrj }
223*38fd1498Szrj
224*38fd1498Szrj vec_free (loops->larray);
225*38fd1498Szrj }
226*38fd1498Szrj }
227*38fd1498Szrj
228*38fd1498Szrj /* Find the nodes contained within the LOOP with header HEADER.
229*38fd1498Szrj Return the number of nodes within the loop. */
230*38fd1498Szrj
231*38fd1498Szrj int
flow_loop_nodes_find(basic_block header,struct loop * loop)232*38fd1498Szrj flow_loop_nodes_find (basic_block header, struct loop *loop)
233*38fd1498Szrj {
234*38fd1498Szrj vec<basic_block> stack = vNULL;
235*38fd1498Szrj int num_nodes = 1;
236*38fd1498Szrj edge latch;
237*38fd1498Szrj edge_iterator latch_ei;
238*38fd1498Szrj
239*38fd1498Szrj header->loop_father = loop;
240*38fd1498Szrj
241*38fd1498Szrj FOR_EACH_EDGE (latch, latch_ei, loop->header->preds)
242*38fd1498Szrj {
243*38fd1498Szrj if (latch->src->loop_father == loop
244*38fd1498Szrj || !dominated_by_p (CDI_DOMINATORS, latch->src, loop->header))
245*38fd1498Szrj continue;
246*38fd1498Szrj
247*38fd1498Szrj num_nodes++;
248*38fd1498Szrj stack.safe_push (latch->src);
249*38fd1498Szrj latch->src->loop_father = loop;
250*38fd1498Szrj
251*38fd1498Szrj while (!stack.is_empty ())
252*38fd1498Szrj {
253*38fd1498Szrj basic_block node;
254*38fd1498Szrj edge e;
255*38fd1498Szrj edge_iterator ei;
256*38fd1498Szrj
257*38fd1498Szrj node = stack.pop ();
258*38fd1498Szrj
259*38fd1498Szrj FOR_EACH_EDGE (e, ei, node->preds)
260*38fd1498Szrj {
261*38fd1498Szrj basic_block ancestor = e->src;
262*38fd1498Szrj
263*38fd1498Szrj if (ancestor->loop_father != loop)
264*38fd1498Szrj {
265*38fd1498Szrj ancestor->loop_father = loop;
266*38fd1498Szrj num_nodes++;
267*38fd1498Szrj stack.safe_push (ancestor);
268*38fd1498Szrj }
269*38fd1498Szrj }
270*38fd1498Szrj }
271*38fd1498Szrj }
272*38fd1498Szrj stack.release ();
273*38fd1498Szrj
274*38fd1498Szrj return num_nodes;
275*38fd1498Szrj }
276*38fd1498Szrj
277*38fd1498Szrj /* Records the vector of superloops of the loop LOOP, whose immediate
278*38fd1498Szrj superloop is FATHER. */
279*38fd1498Szrj
280*38fd1498Szrj static void
establish_preds(struct loop * loop,struct loop * father)281*38fd1498Szrj establish_preds (struct loop *loop, struct loop *father)
282*38fd1498Szrj {
283*38fd1498Szrj loop_p ploop;
284*38fd1498Szrj unsigned depth = loop_depth (father) + 1;
285*38fd1498Szrj unsigned i;
286*38fd1498Szrj
287*38fd1498Szrj loop->superloops = 0;
288*38fd1498Szrj vec_alloc (loop->superloops, depth);
289*38fd1498Szrj FOR_EACH_VEC_SAFE_ELT (father->superloops, i, ploop)
290*38fd1498Szrj loop->superloops->quick_push (ploop);
291*38fd1498Szrj loop->superloops->quick_push (father);
292*38fd1498Szrj
293*38fd1498Szrj for (ploop = loop->inner; ploop; ploop = ploop->next)
294*38fd1498Szrj establish_preds (ploop, loop);
295*38fd1498Szrj }
296*38fd1498Szrj
297*38fd1498Szrj /* Add LOOP to the loop hierarchy tree where FATHER is father of the
298*38fd1498Szrj added loop. If LOOP has some children, take care of that their
299*38fd1498Szrj pred field will be initialized correctly. If AFTER is non-null
300*38fd1498Szrj then it's expected it's a pointer into FATHERs inner sibling
301*38fd1498Szrj list and LOOP is added behind AFTER, otherwise it's added in front
302*38fd1498Szrj of FATHERs siblings. */
303*38fd1498Szrj
304*38fd1498Szrj void
flow_loop_tree_node_add(struct loop * father,struct loop * loop,struct loop * after)305*38fd1498Szrj flow_loop_tree_node_add (struct loop *father, struct loop *loop,
306*38fd1498Szrj struct loop *after)
307*38fd1498Szrj {
308*38fd1498Szrj if (after)
309*38fd1498Szrj {
310*38fd1498Szrj loop->next = after->next;
311*38fd1498Szrj after->next = loop;
312*38fd1498Szrj }
313*38fd1498Szrj else
314*38fd1498Szrj {
315*38fd1498Szrj loop->next = father->inner;
316*38fd1498Szrj father->inner = loop;
317*38fd1498Szrj }
318*38fd1498Szrj
319*38fd1498Szrj establish_preds (loop, father);
320*38fd1498Szrj }
321*38fd1498Szrj
322*38fd1498Szrj /* Remove LOOP from the loop hierarchy tree. */
323*38fd1498Szrj
324*38fd1498Szrj void
flow_loop_tree_node_remove(struct loop * loop)325*38fd1498Szrj flow_loop_tree_node_remove (struct loop *loop)
326*38fd1498Szrj {
327*38fd1498Szrj struct loop *prev, *father;
328*38fd1498Szrj
329*38fd1498Szrj father = loop_outer (loop);
330*38fd1498Szrj
331*38fd1498Szrj /* Remove loop from the list of sons. */
332*38fd1498Szrj if (father->inner == loop)
333*38fd1498Szrj father->inner = loop->next;
334*38fd1498Szrj else
335*38fd1498Szrj {
336*38fd1498Szrj for (prev = father->inner; prev->next != loop; prev = prev->next)
337*38fd1498Szrj continue;
338*38fd1498Szrj prev->next = loop->next;
339*38fd1498Szrj }
340*38fd1498Szrj
341*38fd1498Szrj loop->superloops = NULL;
342*38fd1498Szrj }
343*38fd1498Szrj
344*38fd1498Szrj /* Allocates and returns new loop structure. */
345*38fd1498Szrj
346*38fd1498Szrj struct loop *
alloc_loop(void)347*38fd1498Szrj alloc_loop (void)
348*38fd1498Szrj {
349*38fd1498Szrj struct loop *loop = ggc_cleared_alloc<struct loop> ();
350*38fd1498Szrj
351*38fd1498Szrj loop->exits = ggc_cleared_alloc<loop_exit> ();
352*38fd1498Szrj loop->exits->next = loop->exits->prev = loop->exits;
353*38fd1498Szrj loop->can_be_parallel = false;
354*38fd1498Szrj loop->constraints = 0;
355*38fd1498Szrj loop->nb_iterations_upper_bound = 0;
356*38fd1498Szrj loop->nb_iterations_likely_upper_bound = 0;
357*38fd1498Szrj loop->nb_iterations_estimate = 0;
358*38fd1498Szrj return loop;
359*38fd1498Szrj }
360*38fd1498Szrj
361*38fd1498Szrj /* Initializes loops structure LOOPS, reserving place for NUM_LOOPS loops
362*38fd1498Szrj (including the root of the loop tree). */
363*38fd1498Szrj
364*38fd1498Szrj void
init_loops_structure(struct function * fn,struct loops * loops,unsigned num_loops)365*38fd1498Szrj init_loops_structure (struct function *fn,
366*38fd1498Szrj struct loops *loops, unsigned num_loops)
367*38fd1498Szrj {
368*38fd1498Szrj struct loop *root;
369*38fd1498Szrj
370*38fd1498Szrj memset (loops, 0, sizeof *loops);
371*38fd1498Szrj vec_alloc (loops->larray, num_loops);
372*38fd1498Szrj
373*38fd1498Szrj /* Dummy loop containing whole function. */
374*38fd1498Szrj root = alloc_loop ();
375*38fd1498Szrj root->num_nodes = n_basic_blocks_for_fn (fn);
376*38fd1498Szrj root->latch = EXIT_BLOCK_PTR_FOR_FN (fn);
377*38fd1498Szrj root->header = ENTRY_BLOCK_PTR_FOR_FN (fn);
378*38fd1498Szrj ENTRY_BLOCK_PTR_FOR_FN (fn)->loop_father = root;
379*38fd1498Szrj EXIT_BLOCK_PTR_FOR_FN (fn)->loop_father = root;
380*38fd1498Szrj
381*38fd1498Szrj loops->larray->quick_push (root);
382*38fd1498Szrj loops->tree_root = root;
383*38fd1498Szrj }
384*38fd1498Szrj
385*38fd1498Szrj /* Returns whether HEADER is a loop header. */
386*38fd1498Szrj
387*38fd1498Szrj bool
bb_loop_header_p(basic_block header)388*38fd1498Szrj bb_loop_header_p (basic_block header)
389*38fd1498Szrj {
390*38fd1498Szrj edge_iterator ei;
391*38fd1498Szrj edge e;
392*38fd1498Szrj
393*38fd1498Szrj /* If we have an abnormal predecessor, do not consider the
394*38fd1498Szrj loop (not worth the problems). */
395*38fd1498Szrj if (bb_has_abnormal_pred (header))
396*38fd1498Szrj return false;
397*38fd1498Szrj
398*38fd1498Szrj /* Look for back edges where a predecessor is dominated
399*38fd1498Szrj by this block. A natural loop has a single entry
400*38fd1498Szrj node (header) that dominates all the nodes in the
401*38fd1498Szrj loop. It also has single back edge to the header
402*38fd1498Szrj from a latch node. */
403*38fd1498Szrj FOR_EACH_EDGE (e, ei, header->preds)
404*38fd1498Szrj {
405*38fd1498Szrj basic_block latch = e->src;
406*38fd1498Szrj if (latch != ENTRY_BLOCK_PTR_FOR_FN (cfun)
407*38fd1498Szrj && dominated_by_p (CDI_DOMINATORS, latch, header))
408*38fd1498Szrj return true;
409*38fd1498Szrj }
410*38fd1498Szrj
411*38fd1498Szrj return false;
412*38fd1498Szrj }
413*38fd1498Szrj
414*38fd1498Szrj /* Find all the natural loops in the function and save in LOOPS structure and
415*38fd1498Szrj recalculate loop_father information in basic block structures.
416*38fd1498Szrj If LOOPS is non-NULL then the loop structures for already recorded loops
417*38fd1498Szrj will be re-used and their number will not change. We assume that no
418*38fd1498Szrj stale loops exist in LOOPS.
419*38fd1498Szrj When LOOPS is NULL it is allocated and re-built from scratch.
420*38fd1498Szrj Return the built LOOPS structure. */
421*38fd1498Szrj
422*38fd1498Szrj struct loops *
flow_loops_find(struct loops * loops)423*38fd1498Szrj flow_loops_find (struct loops *loops)
424*38fd1498Szrj {
425*38fd1498Szrj bool from_scratch = (loops == NULL);
426*38fd1498Szrj int *rc_order;
427*38fd1498Szrj int b;
428*38fd1498Szrj unsigned i;
429*38fd1498Szrj
430*38fd1498Szrj /* Ensure that the dominators are computed. */
431*38fd1498Szrj calculate_dominance_info (CDI_DOMINATORS);
432*38fd1498Szrj
433*38fd1498Szrj if (!loops)
434*38fd1498Szrj {
435*38fd1498Szrj loops = ggc_cleared_alloc<struct loops> ();
436*38fd1498Szrj init_loops_structure (cfun, loops, 1);
437*38fd1498Szrj }
438*38fd1498Szrj
439*38fd1498Szrj /* Ensure that loop exits were released. */
440*38fd1498Szrj gcc_assert (loops->exits == NULL);
441*38fd1498Szrj
442*38fd1498Szrj /* Taking care of this degenerate case makes the rest of
443*38fd1498Szrj this code simpler. */
444*38fd1498Szrj if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
445*38fd1498Szrj return loops;
446*38fd1498Szrj
447*38fd1498Szrj /* The root loop node contains all basic-blocks. */
448*38fd1498Szrj loops->tree_root->num_nodes = n_basic_blocks_for_fn (cfun);
449*38fd1498Szrj
450*38fd1498Szrj /* Compute depth first search order of the CFG so that outer
451*38fd1498Szrj natural loops will be found before inner natural loops. */
452*38fd1498Szrj rc_order = XNEWVEC (int, n_basic_blocks_for_fn (cfun));
453*38fd1498Szrj pre_and_rev_post_order_compute (NULL, rc_order, false);
454*38fd1498Szrj
455*38fd1498Szrj /* Gather all loop headers in reverse completion order and allocate
456*38fd1498Szrj loop structures for loops that are not already present. */
457*38fd1498Szrj auto_vec<loop_p> larray (loops->larray->length ());
458*38fd1498Szrj for (b = 0; b < n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS; b++)
459*38fd1498Szrj {
460*38fd1498Szrj basic_block header = BASIC_BLOCK_FOR_FN (cfun, rc_order[b]);
461*38fd1498Szrj if (bb_loop_header_p (header))
462*38fd1498Szrj {
463*38fd1498Szrj struct loop *loop;
464*38fd1498Szrj
465*38fd1498Szrj /* The current active loop tree has valid loop-fathers for
466*38fd1498Szrj header blocks. */
467*38fd1498Szrj if (!from_scratch
468*38fd1498Szrj && header->loop_father->header == header)
469*38fd1498Szrj {
470*38fd1498Szrj loop = header->loop_father;
471*38fd1498Szrj /* If we found an existing loop remove it from the
472*38fd1498Szrj loop tree. It is going to be inserted again
473*38fd1498Szrj below. */
474*38fd1498Szrj flow_loop_tree_node_remove (loop);
475*38fd1498Szrj }
476*38fd1498Szrj else
477*38fd1498Szrj {
478*38fd1498Szrj /* Otherwise allocate a new loop structure for the loop. */
479*38fd1498Szrj loop = alloc_loop ();
480*38fd1498Szrj /* ??? We could re-use unused loop slots here. */
481*38fd1498Szrj loop->num = loops->larray->length ();
482*38fd1498Szrj vec_safe_push (loops->larray, loop);
483*38fd1498Szrj loop->header = header;
484*38fd1498Szrj
485*38fd1498Szrj if (!from_scratch
486*38fd1498Szrj && dump_file && (dump_flags & TDF_DETAILS))
487*38fd1498Szrj fprintf (dump_file, "flow_loops_find: discovered new "
488*38fd1498Szrj "loop %d with header %d\n",
489*38fd1498Szrj loop->num, header->index);
490*38fd1498Szrj }
491*38fd1498Szrj /* Reset latch, we recompute it below. */
492*38fd1498Szrj loop->latch = NULL;
493*38fd1498Szrj larray.safe_push (loop);
494*38fd1498Szrj }
495*38fd1498Szrj
496*38fd1498Szrj /* Make blocks part of the loop root node at start. */
497*38fd1498Szrj header->loop_father = loops->tree_root;
498*38fd1498Szrj }
499*38fd1498Szrj
500*38fd1498Szrj free (rc_order);
501*38fd1498Szrj
502*38fd1498Szrj /* Now iterate over the loops found, insert them into the loop tree
503*38fd1498Szrj and assign basic-block ownership. */
504*38fd1498Szrj for (i = 0; i < larray.length (); ++i)
505*38fd1498Szrj {
506*38fd1498Szrj struct loop *loop = larray[i];
507*38fd1498Szrj basic_block header = loop->header;
508*38fd1498Szrj edge_iterator ei;
509*38fd1498Szrj edge e;
510*38fd1498Szrj
511*38fd1498Szrj flow_loop_tree_node_add (header->loop_father, loop);
512*38fd1498Szrj loop->num_nodes = flow_loop_nodes_find (loop->header, loop);
513*38fd1498Szrj
514*38fd1498Szrj /* Look for the latch for this header block, if it has just a
515*38fd1498Szrj single one. */
516*38fd1498Szrj FOR_EACH_EDGE (e, ei, header->preds)
517*38fd1498Szrj {
518*38fd1498Szrj basic_block latch = e->src;
519*38fd1498Szrj
520*38fd1498Szrj if (flow_bb_inside_loop_p (loop, latch))
521*38fd1498Szrj {
522*38fd1498Szrj if (loop->latch != NULL)
523*38fd1498Szrj {
524*38fd1498Szrj /* More than one latch edge. */
525*38fd1498Szrj loop->latch = NULL;
526*38fd1498Szrj break;
527*38fd1498Szrj }
528*38fd1498Szrj loop->latch = latch;
529*38fd1498Szrj }
530*38fd1498Szrj }
531*38fd1498Szrj }
532*38fd1498Szrj
533*38fd1498Szrj return loops;
534*38fd1498Szrj }
535*38fd1498Szrj
536*38fd1498Szrj /* qsort helper for sort_sibling_loops. */
537*38fd1498Szrj
538*38fd1498Szrj static int *sort_sibling_loops_cmp_rpo;
539*38fd1498Szrj static int
sort_sibling_loops_cmp(const void * la_,const void * lb_)540*38fd1498Szrj sort_sibling_loops_cmp (const void *la_, const void *lb_)
541*38fd1498Szrj {
542*38fd1498Szrj const struct loop *la = *(const struct loop * const *)la_;
543*38fd1498Szrj const struct loop *lb = *(const struct loop * const *)lb_;
544*38fd1498Szrj return (sort_sibling_loops_cmp_rpo[la->header->index]
545*38fd1498Szrj - sort_sibling_loops_cmp_rpo[lb->header->index]);
546*38fd1498Szrj }
547*38fd1498Szrj
548*38fd1498Szrj /* Sort sibling loops in RPO order. */
549*38fd1498Szrj
550*38fd1498Szrj void
sort_sibling_loops(function * fn)551*38fd1498Szrj sort_sibling_loops (function *fn)
552*38fd1498Szrj {
553*38fd1498Szrj /* Match flow_loops_find in the order we sort sibling loops. */
554*38fd1498Szrj sort_sibling_loops_cmp_rpo = XNEWVEC (int, last_basic_block_for_fn (cfun));
555*38fd1498Szrj int *rc_order = XNEWVEC (int, n_basic_blocks_for_fn (cfun));
556*38fd1498Szrj pre_and_rev_post_order_compute_fn (fn, NULL, rc_order, false);
557*38fd1498Szrj for (int i = 0; i < n_basic_blocks_for_fn (cfun) - NUM_FIXED_BLOCKS; ++i)
558*38fd1498Szrj sort_sibling_loops_cmp_rpo[rc_order[i]] = i;
559*38fd1498Szrj free (rc_order);
560*38fd1498Szrj
561*38fd1498Szrj auto_vec<loop_p, 3> siblings;
562*38fd1498Szrj loop_p loop;
563*38fd1498Szrj FOR_EACH_LOOP_FN (fn, loop, LI_INCLUDE_ROOT)
564*38fd1498Szrj if (loop->inner && loop->inner->next)
565*38fd1498Szrj {
566*38fd1498Szrj loop_p sibling = loop->inner;
567*38fd1498Szrj do
568*38fd1498Szrj {
569*38fd1498Szrj siblings.safe_push (sibling);
570*38fd1498Szrj sibling = sibling->next;
571*38fd1498Szrj }
572*38fd1498Szrj while (sibling);
573*38fd1498Szrj siblings.qsort (sort_sibling_loops_cmp);
574*38fd1498Szrj loop_p *siblingp = &loop->inner;
575*38fd1498Szrj for (unsigned i = 0; i < siblings.length (); ++i)
576*38fd1498Szrj {
577*38fd1498Szrj *siblingp = siblings[i];
578*38fd1498Szrj siblingp = &(*siblingp)->next;
579*38fd1498Szrj }
580*38fd1498Szrj *siblingp = NULL;
581*38fd1498Szrj siblings.truncate (0);
582*38fd1498Szrj }
583*38fd1498Szrj
584*38fd1498Szrj free (sort_sibling_loops_cmp_rpo);
585*38fd1498Szrj sort_sibling_loops_cmp_rpo = NULL;
586*38fd1498Szrj }
587*38fd1498Szrj
588*38fd1498Szrj /* Ratio of frequencies of edges so that one of more latch edges is
589*38fd1498Szrj considered to belong to inner loop with same header. */
590*38fd1498Szrj #define HEAVY_EDGE_RATIO 8
591*38fd1498Szrj
592*38fd1498Szrj /* Minimum number of samples for that we apply
593*38fd1498Szrj find_subloop_latch_edge_by_profile heuristics. */
594*38fd1498Szrj #define HEAVY_EDGE_MIN_SAMPLES 10
595*38fd1498Szrj
596*38fd1498Szrj /* If the profile info is available, finds an edge in LATCHES that much more
597*38fd1498Szrj frequent than the remaining edges. Returns such an edge, or NULL if we do
598*38fd1498Szrj not find one.
599*38fd1498Szrj
600*38fd1498Szrj We do not use guessed profile here, only the measured one. The guessed
601*38fd1498Szrj profile is usually too flat and unreliable for this (and it is mostly based
602*38fd1498Szrj on the loop structure of the program, so it does not make much sense to
603*38fd1498Szrj derive the loop structure from it). */
604*38fd1498Szrj
605*38fd1498Szrj static edge
find_subloop_latch_edge_by_profile(vec<edge> latches)606*38fd1498Szrj find_subloop_latch_edge_by_profile (vec<edge> latches)
607*38fd1498Szrj {
608*38fd1498Szrj unsigned i;
609*38fd1498Szrj edge e, me = NULL;
610*38fd1498Szrj profile_count mcount = profile_count::zero (), tcount = profile_count::zero ();
611*38fd1498Szrj
612*38fd1498Szrj FOR_EACH_VEC_ELT (latches, i, e)
613*38fd1498Szrj {
614*38fd1498Szrj if (e->count ()> mcount)
615*38fd1498Szrj {
616*38fd1498Szrj me = e;
617*38fd1498Szrj mcount = e->count();
618*38fd1498Szrj }
619*38fd1498Szrj tcount += e->count();
620*38fd1498Szrj }
621*38fd1498Szrj
622*38fd1498Szrj if (!tcount.initialized_p () || !(tcount.ipa () > HEAVY_EDGE_MIN_SAMPLES)
623*38fd1498Szrj || (tcount - mcount).apply_scale (HEAVY_EDGE_RATIO, 1) > tcount)
624*38fd1498Szrj return NULL;
625*38fd1498Szrj
626*38fd1498Szrj if (dump_file)
627*38fd1498Szrj fprintf (dump_file,
628*38fd1498Szrj "Found latch edge %d -> %d using profile information.\n",
629*38fd1498Szrj me->src->index, me->dest->index);
630*38fd1498Szrj return me;
631*38fd1498Szrj }
632*38fd1498Szrj
633*38fd1498Szrj /* Among LATCHES, guesses a latch edge of LOOP corresponding to subloop, based
634*38fd1498Szrj on the structure of induction variables. Returns this edge, or NULL if we
635*38fd1498Szrj do not find any.
636*38fd1498Szrj
637*38fd1498Szrj We are quite conservative, and look just for an obvious simple innermost
638*38fd1498Szrj loop (which is the case where we would lose the most performance by not
639*38fd1498Szrj disambiguating the loop). More precisely, we look for the following
640*38fd1498Szrj situation: The source of the chosen latch edge dominates sources of all
641*38fd1498Szrj the other latch edges. Additionally, the header does not contain a phi node
642*38fd1498Szrj such that the argument from the chosen edge is equal to the argument from
643*38fd1498Szrj another edge. */
644*38fd1498Szrj
645*38fd1498Szrj static edge
find_subloop_latch_edge_by_ivs(struct loop * loop ATTRIBUTE_UNUSED,vec<edge> latches)646*38fd1498Szrj find_subloop_latch_edge_by_ivs (struct loop *loop ATTRIBUTE_UNUSED, vec<edge> latches)
647*38fd1498Szrj {
648*38fd1498Szrj edge e, latch = latches[0];
649*38fd1498Szrj unsigned i;
650*38fd1498Szrj gphi *phi;
651*38fd1498Szrj gphi_iterator psi;
652*38fd1498Szrj tree lop;
653*38fd1498Szrj basic_block bb;
654*38fd1498Szrj
655*38fd1498Szrj /* Find the candidate for the latch edge. */
656*38fd1498Szrj for (i = 1; latches.iterate (i, &e); i++)
657*38fd1498Szrj if (dominated_by_p (CDI_DOMINATORS, latch->src, e->src))
658*38fd1498Szrj latch = e;
659*38fd1498Szrj
660*38fd1498Szrj /* Verify that it dominates all the latch edges. */
661*38fd1498Szrj FOR_EACH_VEC_ELT (latches, i, e)
662*38fd1498Szrj if (!dominated_by_p (CDI_DOMINATORS, e->src, latch->src))
663*38fd1498Szrj return NULL;
664*38fd1498Szrj
665*38fd1498Szrj /* Check for a phi node that would deny that this is a latch edge of
666*38fd1498Szrj a subloop. */
667*38fd1498Szrj for (psi = gsi_start_phis (loop->header); !gsi_end_p (psi); gsi_next (&psi))
668*38fd1498Szrj {
669*38fd1498Szrj phi = psi.phi ();
670*38fd1498Szrj lop = PHI_ARG_DEF_FROM_EDGE (phi, latch);
671*38fd1498Szrj
672*38fd1498Szrj /* Ignore the values that are not changed inside the subloop. */
673*38fd1498Szrj if (TREE_CODE (lop) != SSA_NAME
674*38fd1498Szrj || SSA_NAME_DEF_STMT (lop) == phi)
675*38fd1498Szrj continue;
676*38fd1498Szrj bb = gimple_bb (SSA_NAME_DEF_STMT (lop));
677*38fd1498Szrj if (!bb || !flow_bb_inside_loop_p (loop, bb))
678*38fd1498Szrj continue;
679*38fd1498Szrj
680*38fd1498Szrj FOR_EACH_VEC_ELT (latches, i, e)
681*38fd1498Szrj if (e != latch
682*38fd1498Szrj && PHI_ARG_DEF_FROM_EDGE (phi, e) == lop)
683*38fd1498Szrj return NULL;
684*38fd1498Szrj }
685*38fd1498Szrj
686*38fd1498Szrj if (dump_file)
687*38fd1498Szrj fprintf (dump_file,
688*38fd1498Szrj "Found latch edge %d -> %d using iv structure.\n",
689*38fd1498Szrj latch->src->index, latch->dest->index);
690*38fd1498Szrj return latch;
691*38fd1498Szrj }
692*38fd1498Szrj
693*38fd1498Szrj /* If we can determine that one of the several latch edges of LOOP behaves
694*38fd1498Szrj as a latch edge of a separate subloop, returns this edge. Otherwise
695*38fd1498Szrj returns NULL. */
696*38fd1498Szrj
697*38fd1498Szrj static edge
find_subloop_latch_edge(struct loop * loop)698*38fd1498Szrj find_subloop_latch_edge (struct loop *loop)
699*38fd1498Szrj {
700*38fd1498Szrj vec<edge> latches = get_loop_latch_edges (loop);
701*38fd1498Szrj edge latch = NULL;
702*38fd1498Szrj
703*38fd1498Szrj if (latches.length () > 1)
704*38fd1498Szrj {
705*38fd1498Szrj latch = find_subloop_latch_edge_by_profile (latches);
706*38fd1498Szrj
707*38fd1498Szrj if (!latch
708*38fd1498Szrj /* We consider ivs to guess the latch edge only in SSA. Perhaps we
709*38fd1498Szrj should use cfghook for this, but it is hard to imagine it would
710*38fd1498Szrj be useful elsewhere. */
711*38fd1498Szrj && current_ir_type () == IR_GIMPLE)
712*38fd1498Szrj latch = find_subloop_latch_edge_by_ivs (loop, latches);
713*38fd1498Szrj }
714*38fd1498Szrj
715*38fd1498Szrj latches.release ();
716*38fd1498Szrj return latch;
717*38fd1498Szrj }
718*38fd1498Szrj
719*38fd1498Szrj /* Callback for make_forwarder_block. Returns true if the edge E is marked
720*38fd1498Szrj in the set MFB_REIS_SET. */
721*38fd1498Szrj
722*38fd1498Szrj static hash_set<edge> *mfb_reis_set;
723*38fd1498Szrj static bool
mfb_redirect_edges_in_set(edge e)724*38fd1498Szrj mfb_redirect_edges_in_set (edge e)
725*38fd1498Szrj {
726*38fd1498Szrj return mfb_reis_set->contains (e);
727*38fd1498Szrj }
728*38fd1498Szrj
729*38fd1498Szrj /* Creates a subloop of LOOP with latch edge LATCH. */
730*38fd1498Szrj
731*38fd1498Szrj static void
form_subloop(struct loop * loop,edge latch)732*38fd1498Szrj form_subloop (struct loop *loop, edge latch)
733*38fd1498Szrj {
734*38fd1498Szrj edge_iterator ei;
735*38fd1498Szrj edge e, new_entry;
736*38fd1498Szrj struct loop *new_loop;
737*38fd1498Szrj
738*38fd1498Szrj mfb_reis_set = new hash_set<edge>;
739*38fd1498Szrj FOR_EACH_EDGE (e, ei, loop->header->preds)
740*38fd1498Szrj {
741*38fd1498Szrj if (e != latch)
742*38fd1498Szrj mfb_reis_set->add (e);
743*38fd1498Szrj }
744*38fd1498Szrj new_entry = make_forwarder_block (loop->header, mfb_redirect_edges_in_set,
745*38fd1498Szrj NULL);
746*38fd1498Szrj delete mfb_reis_set;
747*38fd1498Szrj
748*38fd1498Szrj loop->header = new_entry->src;
749*38fd1498Szrj
750*38fd1498Szrj /* Find the blocks and subloops that belong to the new loop, and add it to
751*38fd1498Szrj the appropriate place in the loop tree. */
752*38fd1498Szrj new_loop = alloc_loop ();
753*38fd1498Szrj new_loop->header = new_entry->dest;
754*38fd1498Szrj new_loop->latch = latch->src;
755*38fd1498Szrj add_loop (new_loop, loop);
756*38fd1498Szrj }
757*38fd1498Szrj
758*38fd1498Szrj /* Make all the latch edges of LOOP to go to a single forwarder block --
759*38fd1498Szrj a new latch of LOOP. */
760*38fd1498Szrj
761*38fd1498Szrj static void
merge_latch_edges(struct loop * loop)762*38fd1498Szrj merge_latch_edges (struct loop *loop)
763*38fd1498Szrj {
764*38fd1498Szrj vec<edge> latches = get_loop_latch_edges (loop);
765*38fd1498Szrj edge latch, e;
766*38fd1498Szrj unsigned i;
767*38fd1498Szrj
768*38fd1498Szrj gcc_assert (latches.length () > 0);
769*38fd1498Szrj
770*38fd1498Szrj if (latches.length () == 1)
771*38fd1498Szrj loop->latch = latches[0]->src;
772*38fd1498Szrj else
773*38fd1498Szrj {
774*38fd1498Szrj if (dump_file)
775*38fd1498Szrj fprintf (dump_file, "Merged latch edges of loop %d\n", loop->num);
776*38fd1498Szrj
777*38fd1498Szrj mfb_reis_set = new hash_set<edge>;
778*38fd1498Szrj FOR_EACH_VEC_ELT (latches, i, e)
779*38fd1498Szrj mfb_reis_set->add (e);
780*38fd1498Szrj latch = make_forwarder_block (loop->header, mfb_redirect_edges_in_set,
781*38fd1498Szrj NULL);
782*38fd1498Szrj delete mfb_reis_set;
783*38fd1498Szrj
784*38fd1498Szrj loop->header = latch->dest;
785*38fd1498Szrj loop->latch = latch->src;
786*38fd1498Szrj }
787*38fd1498Szrj
788*38fd1498Szrj latches.release ();
789*38fd1498Szrj }
790*38fd1498Szrj
791*38fd1498Szrj /* LOOP may have several latch edges. Transform it into (possibly several)
792*38fd1498Szrj loops with single latch edge. */
793*38fd1498Szrj
794*38fd1498Szrj static void
disambiguate_multiple_latches(struct loop * loop)795*38fd1498Szrj disambiguate_multiple_latches (struct loop *loop)
796*38fd1498Szrj {
797*38fd1498Szrj edge e;
798*38fd1498Szrj
799*38fd1498Szrj /* We eliminate the multiple latches by splitting the header to the forwarder
800*38fd1498Szrj block F and the rest R, and redirecting the edges. There are two cases:
801*38fd1498Szrj
802*38fd1498Szrj 1) If there is a latch edge E that corresponds to a subloop (we guess
803*38fd1498Szrj that based on profile -- if it is taken much more often than the
804*38fd1498Szrj remaining edges; and on trees, using the information about induction
805*38fd1498Szrj variables of the loops), we redirect E to R, all the remaining edges to
806*38fd1498Szrj F, then rescan the loops and try again for the outer loop.
807*38fd1498Szrj 2) If there is no such edge, we redirect all latch edges to F, and the
808*38fd1498Szrj entry edges to R, thus making F the single latch of the loop. */
809*38fd1498Szrj
810*38fd1498Szrj if (dump_file)
811*38fd1498Szrj fprintf (dump_file, "Disambiguating loop %d with multiple latches\n",
812*38fd1498Szrj loop->num);
813*38fd1498Szrj
814*38fd1498Szrj /* During latch merging, we may need to redirect the entry edges to a new
815*38fd1498Szrj block. This would cause problems if the entry edge was the one from the
816*38fd1498Szrj entry block. To avoid having to handle this case specially, split
817*38fd1498Szrj such entry edge. */
818*38fd1498Szrj e = find_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), loop->header);
819*38fd1498Szrj if (e)
820*38fd1498Szrj split_edge (e);
821*38fd1498Szrj
822*38fd1498Szrj while (1)
823*38fd1498Szrj {
824*38fd1498Szrj e = find_subloop_latch_edge (loop);
825*38fd1498Szrj if (!e)
826*38fd1498Szrj break;
827*38fd1498Szrj
828*38fd1498Szrj form_subloop (loop, e);
829*38fd1498Szrj }
830*38fd1498Szrj
831*38fd1498Szrj merge_latch_edges (loop);
832*38fd1498Szrj }
833*38fd1498Szrj
834*38fd1498Szrj /* Split loops with multiple latch edges. */
835*38fd1498Szrj
836*38fd1498Szrj void
disambiguate_loops_with_multiple_latches(void)837*38fd1498Szrj disambiguate_loops_with_multiple_latches (void)
838*38fd1498Szrj {
839*38fd1498Szrj struct loop *loop;
840*38fd1498Szrj
841*38fd1498Szrj FOR_EACH_LOOP (loop, 0)
842*38fd1498Szrj {
843*38fd1498Szrj if (!loop->latch)
844*38fd1498Szrj disambiguate_multiple_latches (loop);
845*38fd1498Szrj }
846*38fd1498Szrj }
847*38fd1498Szrj
848*38fd1498Szrj /* Return nonzero if basic block BB belongs to LOOP. */
849*38fd1498Szrj bool
flow_bb_inside_loop_p(const struct loop * loop,const_basic_block bb)850*38fd1498Szrj flow_bb_inside_loop_p (const struct loop *loop, const_basic_block bb)
851*38fd1498Szrj {
852*38fd1498Szrj struct loop *source_loop;
853*38fd1498Szrj
854*38fd1498Szrj if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)
855*38fd1498Szrj || bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
856*38fd1498Szrj return 0;
857*38fd1498Szrj
858*38fd1498Szrj source_loop = bb->loop_father;
859*38fd1498Szrj return loop == source_loop || flow_loop_nested_p (loop, source_loop);
860*38fd1498Szrj }
861*38fd1498Szrj
862*38fd1498Szrj /* Enumeration predicate for get_loop_body_with_size. */
863*38fd1498Szrj static bool
glb_enum_p(const_basic_block bb,const void * glb_loop)864*38fd1498Szrj glb_enum_p (const_basic_block bb, const void *glb_loop)
865*38fd1498Szrj {
866*38fd1498Szrj const struct loop *const loop = (const struct loop *) glb_loop;
867*38fd1498Szrj return (bb != loop->header
868*38fd1498Szrj && dominated_by_p (CDI_DOMINATORS, bb, loop->header));
869*38fd1498Szrj }
870*38fd1498Szrj
871*38fd1498Szrj /* Gets basic blocks of a LOOP. Header is the 0-th block, rest is in dfs
872*38fd1498Szrj order against direction of edges from latch. Specially, if
873*38fd1498Szrj header != latch, latch is the 1-st block. LOOP cannot be the fake
874*38fd1498Szrj loop tree root, and its size must be at most MAX_SIZE. The blocks
875*38fd1498Szrj in the LOOP body are stored to BODY, and the size of the LOOP is
876*38fd1498Szrj returned. */
877*38fd1498Szrj
878*38fd1498Szrj unsigned
get_loop_body_with_size(const struct loop * loop,basic_block * body,unsigned max_size)879*38fd1498Szrj get_loop_body_with_size (const struct loop *loop, basic_block *body,
880*38fd1498Szrj unsigned max_size)
881*38fd1498Szrj {
882*38fd1498Szrj return dfs_enumerate_from (loop->header, 1, glb_enum_p,
883*38fd1498Szrj body, max_size, loop);
884*38fd1498Szrj }
885*38fd1498Szrj
886*38fd1498Szrj /* Gets basic blocks of a LOOP. Header is the 0-th block, rest is in dfs
887*38fd1498Szrj order against direction of edges from latch. Specially, if
888*38fd1498Szrj header != latch, latch is the 1-st block. */
889*38fd1498Szrj
890*38fd1498Szrj basic_block *
get_loop_body(const struct loop * loop)891*38fd1498Szrj get_loop_body (const struct loop *loop)
892*38fd1498Szrj {
893*38fd1498Szrj basic_block *body, bb;
894*38fd1498Szrj unsigned tv = 0;
895*38fd1498Szrj
896*38fd1498Szrj gcc_assert (loop->num_nodes);
897*38fd1498Szrj
898*38fd1498Szrj body = XNEWVEC (basic_block, loop->num_nodes);
899*38fd1498Szrj
900*38fd1498Szrj if (loop->latch == EXIT_BLOCK_PTR_FOR_FN (cfun))
901*38fd1498Szrj {
902*38fd1498Szrj /* There may be blocks unreachable from EXIT_BLOCK, hence we need to
903*38fd1498Szrj special-case the fake loop that contains the whole function. */
904*38fd1498Szrj gcc_assert (loop->num_nodes == (unsigned) n_basic_blocks_for_fn (cfun));
905*38fd1498Szrj body[tv++] = loop->header;
906*38fd1498Szrj body[tv++] = EXIT_BLOCK_PTR_FOR_FN (cfun);
907*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
908*38fd1498Szrj body[tv++] = bb;
909*38fd1498Szrj }
910*38fd1498Szrj else
911*38fd1498Szrj tv = get_loop_body_with_size (loop, body, loop->num_nodes);
912*38fd1498Szrj
913*38fd1498Szrj gcc_assert (tv == loop->num_nodes);
914*38fd1498Szrj return body;
915*38fd1498Szrj }
916*38fd1498Szrj
917*38fd1498Szrj /* Fills dominance descendants inside LOOP of the basic block BB into
918*38fd1498Szrj array TOVISIT from index *TV. */
919*38fd1498Szrj
920*38fd1498Szrj static void
fill_sons_in_loop(const struct loop * loop,basic_block bb,basic_block * tovisit,int * tv)921*38fd1498Szrj fill_sons_in_loop (const struct loop *loop, basic_block bb,
922*38fd1498Szrj basic_block *tovisit, int *tv)
923*38fd1498Szrj {
924*38fd1498Szrj basic_block son, postpone = NULL;
925*38fd1498Szrj
926*38fd1498Szrj tovisit[(*tv)++] = bb;
927*38fd1498Szrj for (son = first_dom_son (CDI_DOMINATORS, bb);
928*38fd1498Szrj son;
929*38fd1498Szrj son = next_dom_son (CDI_DOMINATORS, son))
930*38fd1498Szrj {
931*38fd1498Szrj if (!flow_bb_inside_loop_p (loop, son))
932*38fd1498Szrj continue;
933*38fd1498Szrj
934*38fd1498Szrj if (dominated_by_p (CDI_DOMINATORS, loop->latch, son))
935*38fd1498Szrj {
936*38fd1498Szrj postpone = son;
937*38fd1498Szrj continue;
938*38fd1498Szrj }
939*38fd1498Szrj fill_sons_in_loop (loop, son, tovisit, tv);
940*38fd1498Szrj }
941*38fd1498Szrj
942*38fd1498Szrj if (postpone)
943*38fd1498Szrj fill_sons_in_loop (loop, postpone, tovisit, tv);
944*38fd1498Szrj }
945*38fd1498Szrj
946*38fd1498Szrj /* Gets body of a LOOP (that must be different from the outermost loop)
947*38fd1498Szrj sorted by dominance relation. Additionally, if a basic block s dominates
948*38fd1498Szrj the latch, then only blocks dominated by s are be after it. */
949*38fd1498Szrj
950*38fd1498Szrj basic_block *
get_loop_body_in_dom_order(const struct loop * loop)951*38fd1498Szrj get_loop_body_in_dom_order (const struct loop *loop)
952*38fd1498Szrj {
953*38fd1498Szrj basic_block *tovisit;
954*38fd1498Szrj int tv;
955*38fd1498Szrj
956*38fd1498Szrj gcc_assert (loop->num_nodes);
957*38fd1498Szrj
958*38fd1498Szrj tovisit = XNEWVEC (basic_block, loop->num_nodes);
959*38fd1498Szrj
960*38fd1498Szrj gcc_assert (loop->latch != EXIT_BLOCK_PTR_FOR_FN (cfun));
961*38fd1498Szrj
962*38fd1498Szrj tv = 0;
963*38fd1498Szrj fill_sons_in_loop (loop, loop->header, tovisit, &tv);
964*38fd1498Szrj
965*38fd1498Szrj gcc_assert (tv == (int) loop->num_nodes);
966*38fd1498Szrj
967*38fd1498Szrj return tovisit;
968*38fd1498Szrj }
969*38fd1498Szrj
970*38fd1498Szrj /* Gets body of a LOOP sorted via provided BB_COMPARATOR. */
971*38fd1498Szrj
972*38fd1498Szrj basic_block *
get_loop_body_in_custom_order(const struct loop * loop,int (* bb_comparator)(const void *,const void *))973*38fd1498Szrj get_loop_body_in_custom_order (const struct loop *loop,
974*38fd1498Szrj int (*bb_comparator) (const void *, const void *))
975*38fd1498Szrj {
976*38fd1498Szrj basic_block *bbs = get_loop_body (loop);
977*38fd1498Szrj
978*38fd1498Szrj qsort (bbs, loop->num_nodes, sizeof (basic_block), bb_comparator);
979*38fd1498Szrj
980*38fd1498Szrj return bbs;
981*38fd1498Szrj }
982*38fd1498Szrj
983*38fd1498Szrj /* Get body of a LOOP in breadth first sort order. */
984*38fd1498Szrj
985*38fd1498Szrj basic_block *
get_loop_body_in_bfs_order(const struct loop * loop)986*38fd1498Szrj get_loop_body_in_bfs_order (const struct loop *loop)
987*38fd1498Szrj {
988*38fd1498Szrj basic_block *blocks;
989*38fd1498Szrj basic_block bb;
990*38fd1498Szrj unsigned int i = 1;
991*38fd1498Szrj unsigned int vc = 0;
992*38fd1498Szrj
993*38fd1498Szrj gcc_assert (loop->num_nodes);
994*38fd1498Szrj gcc_assert (loop->latch != EXIT_BLOCK_PTR_FOR_FN (cfun));
995*38fd1498Szrj
996*38fd1498Szrj blocks = XNEWVEC (basic_block, loop->num_nodes);
997*38fd1498Szrj auto_bitmap visited;
998*38fd1498Szrj blocks[0] = loop->header;
999*38fd1498Szrj bitmap_set_bit (visited, loop->header->index);
1000*38fd1498Szrj while (i < loop->num_nodes)
1001*38fd1498Szrj {
1002*38fd1498Szrj edge e;
1003*38fd1498Szrj edge_iterator ei;
1004*38fd1498Szrj gcc_assert (i > vc);
1005*38fd1498Szrj bb = blocks[vc++];
1006*38fd1498Szrj
1007*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1008*38fd1498Szrj {
1009*38fd1498Szrj if (flow_bb_inside_loop_p (loop, e->dest))
1010*38fd1498Szrj {
1011*38fd1498Szrj /* This bb is now visited. */
1012*38fd1498Szrj if (bitmap_set_bit (visited, e->dest->index))
1013*38fd1498Szrj blocks[i++] = e->dest;
1014*38fd1498Szrj }
1015*38fd1498Szrj }
1016*38fd1498Szrj }
1017*38fd1498Szrj
1018*38fd1498Szrj return blocks;
1019*38fd1498Szrj }
1020*38fd1498Szrj
1021*38fd1498Szrj /* Hash function for struct loop_exit. */
1022*38fd1498Szrj
1023*38fd1498Szrj hashval_t
hash(loop_exit * exit)1024*38fd1498Szrj loop_exit_hasher::hash (loop_exit *exit)
1025*38fd1498Szrj {
1026*38fd1498Szrj return htab_hash_pointer (exit->e);
1027*38fd1498Szrj }
1028*38fd1498Szrj
1029*38fd1498Szrj /* Equality function for struct loop_exit. Compares with edge. */
1030*38fd1498Szrj
1031*38fd1498Szrj bool
equal(loop_exit * exit,edge e)1032*38fd1498Szrj loop_exit_hasher::equal (loop_exit *exit, edge e)
1033*38fd1498Szrj {
1034*38fd1498Szrj return exit->e == e;
1035*38fd1498Szrj }
1036*38fd1498Szrj
1037*38fd1498Szrj /* Frees the list of loop exit descriptions EX. */
1038*38fd1498Szrj
1039*38fd1498Szrj void
remove(loop_exit * exit)1040*38fd1498Szrj loop_exit_hasher::remove (loop_exit *exit)
1041*38fd1498Szrj {
1042*38fd1498Szrj loop_exit *next;
1043*38fd1498Szrj for (; exit; exit = next)
1044*38fd1498Szrj {
1045*38fd1498Szrj next = exit->next_e;
1046*38fd1498Szrj
1047*38fd1498Szrj exit->next->prev = exit->prev;
1048*38fd1498Szrj exit->prev->next = exit->next;
1049*38fd1498Szrj
1050*38fd1498Szrj ggc_free (exit);
1051*38fd1498Szrj }
1052*38fd1498Szrj }
1053*38fd1498Szrj
1054*38fd1498Szrj /* Returns the list of records for E as an exit of a loop. */
1055*38fd1498Szrj
1056*38fd1498Szrj static struct loop_exit *
get_exit_descriptions(edge e)1057*38fd1498Szrj get_exit_descriptions (edge e)
1058*38fd1498Szrj {
1059*38fd1498Szrj return current_loops->exits->find_with_hash (e, htab_hash_pointer (e));
1060*38fd1498Szrj }
1061*38fd1498Szrj
1062*38fd1498Szrj /* Updates the lists of loop exits in that E appears.
1063*38fd1498Szrj If REMOVED is true, E is being removed, and we
1064*38fd1498Szrj just remove it from the lists of exits.
1065*38fd1498Szrj If NEW_EDGE is true and E is not a loop exit, we
1066*38fd1498Szrj do not try to remove it from loop exit lists. */
1067*38fd1498Szrj
1068*38fd1498Szrj void
rescan_loop_exit(edge e,bool new_edge,bool removed)1069*38fd1498Szrj rescan_loop_exit (edge e, bool new_edge, bool removed)
1070*38fd1498Szrj {
1071*38fd1498Szrj struct loop_exit *exits = NULL, *exit;
1072*38fd1498Szrj struct loop *aloop, *cloop;
1073*38fd1498Szrj
1074*38fd1498Szrj if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
1075*38fd1498Szrj return;
1076*38fd1498Szrj
1077*38fd1498Szrj if (!removed
1078*38fd1498Szrj && e->src->loop_father != NULL
1079*38fd1498Szrj && e->dest->loop_father != NULL
1080*38fd1498Szrj && !flow_bb_inside_loop_p (e->src->loop_father, e->dest))
1081*38fd1498Szrj {
1082*38fd1498Szrj cloop = find_common_loop (e->src->loop_father, e->dest->loop_father);
1083*38fd1498Szrj for (aloop = e->src->loop_father;
1084*38fd1498Szrj aloop != cloop;
1085*38fd1498Szrj aloop = loop_outer (aloop))
1086*38fd1498Szrj {
1087*38fd1498Szrj exit = ggc_alloc<loop_exit> ();
1088*38fd1498Szrj exit->e = e;
1089*38fd1498Szrj
1090*38fd1498Szrj exit->next = aloop->exits->next;
1091*38fd1498Szrj exit->prev = aloop->exits;
1092*38fd1498Szrj exit->next->prev = exit;
1093*38fd1498Szrj exit->prev->next = exit;
1094*38fd1498Szrj
1095*38fd1498Szrj exit->next_e = exits;
1096*38fd1498Szrj exits = exit;
1097*38fd1498Szrj }
1098*38fd1498Szrj }
1099*38fd1498Szrj
1100*38fd1498Szrj if (!exits && new_edge)
1101*38fd1498Szrj return;
1102*38fd1498Szrj
1103*38fd1498Szrj loop_exit **slot
1104*38fd1498Szrj = current_loops->exits->find_slot_with_hash (e, htab_hash_pointer (e),
1105*38fd1498Szrj exits ? INSERT : NO_INSERT);
1106*38fd1498Szrj if (!slot)
1107*38fd1498Szrj return;
1108*38fd1498Szrj
1109*38fd1498Szrj if (exits)
1110*38fd1498Szrj {
1111*38fd1498Szrj if (*slot)
1112*38fd1498Szrj loop_exit_hasher::remove (*slot);
1113*38fd1498Szrj *slot = exits;
1114*38fd1498Szrj }
1115*38fd1498Szrj else
1116*38fd1498Szrj current_loops->exits->clear_slot (slot);
1117*38fd1498Szrj }
1118*38fd1498Szrj
1119*38fd1498Szrj /* For each loop, record list of exit edges, and start maintaining these
1120*38fd1498Szrj lists. */
1121*38fd1498Szrj
1122*38fd1498Szrj void
record_loop_exits(void)1123*38fd1498Szrj record_loop_exits (void)
1124*38fd1498Szrj {
1125*38fd1498Szrj basic_block bb;
1126*38fd1498Szrj edge_iterator ei;
1127*38fd1498Szrj edge e;
1128*38fd1498Szrj
1129*38fd1498Szrj if (!current_loops)
1130*38fd1498Szrj return;
1131*38fd1498Szrj
1132*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
1133*38fd1498Szrj return;
1134*38fd1498Szrj loops_state_set (LOOPS_HAVE_RECORDED_EXITS);
1135*38fd1498Szrj
1136*38fd1498Szrj gcc_assert (current_loops->exits == NULL);
1137*38fd1498Szrj current_loops->exits
1138*38fd1498Szrj = hash_table<loop_exit_hasher>::create_ggc (2 * number_of_loops (cfun));
1139*38fd1498Szrj
1140*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
1141*38fd1498Szrj {
1142*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1143*38fd1498Szrj {
1144*38fd1498Szrj rescan_loop_exit (e, true, false);
1145*38fd1498Szrj }
1146*38fd1498Szrj }
1147*38fd1498Szrj }
1148*38fd1498Szrj
1149*38fd1498Szrj /* Dumps information about the exit in *SLOT to FILE.
1150*38fd1498Szrj Callback for htab_traverse. */
1151*38fd1498Szrj
1152*38fd1498Szrj int
dump_recorded_exit(loop_exit ** slot,FILE * file)1153*38fd1498Szrj dump_recorded_exit (loop_exit **slot, FILE *file)
1154*38fd1498Szrj {
1155*38fd1498Szrj struct loop_exit *exit = *slot;
1156*38fd1498Szrj unsigned n = 0;
1157*38fd1498Szrj edge e = exit->e;
1158*38fd1498Szrj
1159*38fd1498Szrj for (; exit != NULL; exit = exit->next_e)
1160*38fd1498Szrj n++;
1161*38fd1498Szrj
1162*38fd1498Szrj fprintf (file, "Edge %d->%d exits %u loops\n",
1163*38fd1498Szrj e->src->index, e->dest->index, n);
1164*38fd1498Szrj
1165*38fd1498Szrj return 1;
1166*38fd1498Szrj }
1167*38fd1498Szrj
1168*38fd1498Szrj /* Dumps the recorded exits of loops to FILE. */
1169*38fd1498Szrj
1170*38fd1498Szrj extern void dump_recorded_exits (FILE *);
1171*38fd1498Szrj void
dump_recorded_exits(FILE * file)1172*38fd1498Szrj dump_recorded_exits (FILE *file)
1173*38fd1498Szrj {
1174*38fd1498Szrj if (!current_loops->exits)
1175*38fd1498Szrj return;
1176*38fd1498Szrj current_loops->exits->traverse<FILE *, dump_recorded_exit> (file);
1177*38fd1498Szrj }
1178*38fd1498Szrj
1179*38fd1498Szrj /* Releases lists of loop exits. */
1180*38fd1498Szrj
1181*38fd1498Szrj void
release_recorded_exits(function * fn)1182*38fd1498Szrj release_recorded_exits (function *fn)
1183*38fd1498Szrj {
1184*38fd1498Szrj gcc_assert (loops_state_satisfies_p (fn, LOOPS_HAVE_RECORDED_EXITS));
1185*38fd1498Szrj loops_for_fn (fn)->exits->empty ();
1186*38fd1498Szrj loops_for_fn (fn)->exits = NULL;
1187*38fd1498Szrj loops_state_clear (fn, LOOPS_HAVE_RECORDED_EXITS);
1188*38fd1498Szrj }
1189*38fd1498Szrj
1190*38fd1498Szrj /* Returns the list of the exit edges of a LOOP. */
1191*38fd1498Szrj
1192*38fd1498Szrj vec<edge>
get_loop_exit_edges(const struct loop * loop)1193*38fd1498Szrj get_loop_exit_edges (const struct loop *loop)
1194*38fd1498Szrj {
1195*38fd1498Szrj vec<edge> edges = vNULL;
1196*38fd1498Szrj edge e;
1197*38fd1498Szrj unsigned i;
1198*38fd1498Szrj basic_block *body;
1199*38fd1498Szrj edge_iterator ei;
1200*38fd1498Szrj struct loop_exit *exit;
1201*38fd1498Szrj
1202*38fd1498Szrj gcc_assert (loop->latch != EXIT_BLOCK_PTR_FOR_FN (cfun));
1203*38fd1498Szrj
1204*38fd1498Szrj /* If we maintain the lists of exits, use them. Otherwise we must
1205*38fd1498Szrj scan the body of the loop. */
1206*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
1207*38fd1498Szrj {
1208*38fd1498Szrj for (exit = loop->exits->next; exit->e; exit = exit->next)
1209*38fd1498Szrj edges.safe_push (exit->e);
1210*38fd1498Szrj }
1211*38fd1498Szrj else
1212*38fd1498Szrj {
1213*38fd1498Szrj body = get_loop_body (loop);
1214*38fd1498Szrj for (i = 0; i < loop->num_nodes; i++)
1215*38fd1498Szrj FOR_EACH_EDGE (e, ei, body[i]->succs)
1216*38fd1498Szrj {
1217*38fd1498Szrj if (!flow_bb_inside_loop_p (loop, e->dest))
1218*38fd1498Szrj edges.safe_push (e);
1219*38fd1498Szrj }
1220*38fd1498Szrj free (body);
1221*38fd1498Szrj }
1222*38fd1498Szrj
1223*38fd1498Szrj return edges;
1224*38fd1498Szrj }
1225*38fd1498Szrj
1226*38fd1498Szrj /* Counts the number of conditional branches inside LOOP. */
1227*38fd1498Szrj
1228*38fd1498Szrj unsigned
num_loop_branches(const struct loop * loop)1229*38fd1498Szrj num_loop_branches (const struct loop *loop)
1230*38fd1498Szrj {
1231*38fd1498Szrj unsigned i, n;
1232*38fd1498Szrj basic_block * body;
1233*38fd1498Szrj
1234*38fd1498Szrj gcc_assert (loop->latch != EXIT_BLOCK_PTR_FOR_FN (cfun));
1235*38fd1498Szrj
1236*38fd1498Szrj body = get_loop_body (loop);
1237*38fd1498Szrj n = 0;
1238*38fd1498Szrj for (i = 0; i < loop->num_nodes; i++)
1239*38fd1498Szrj if (EDGE_COUNT (body[i]->succs) >= 2)
1240*38fd1498Szrj n++;
1241*38fd1498Szrj free (body);
1242*38fd1498Szrj
1243*38fd1498Szrj return n;
1244*38fd1498Szrj }
1245*38fd1498Szrj
1246*38fd1498Szrj /* Adds basic block BB to LOOP. */
1247*38fd1498Szrj void
add_bb_to_loop(basic_block bb,struct loop * loop)1248*38fd1498Szrj add_bb_to_loop (basic_block bb, struct loop *loop)
1249*38fd1498Szrj {
1250*38fd1498Szrj unsigned i;
1251*38fd1498Szrj loop_p ploop;
1252*38fd1498Szrj edge_iterator ei;
1253*38fd1498Szrj edge e;
1254*38fd1498Szrj
1255*38fd1498Szrj gcc_assert (bb->loop_father == NULL);
1256*38fd1498Szrj bb->loop_father = loop;
1257*38fd1498Szrj loop->num_nodes++;
1258*38fd1498Szrj FOR_EACH_VEC_SAFE_ELT (loop->superloops, i, ploop)
1259*38fd1498Szrj ploop->num_nodes++;
1260*38fd1498Szrj
1261*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1262*38fd1498Szrj {
1263*38fd1498Szrj rescan_loop_exit (e, true, false);
1264*38fd1498Szrj }
1265*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->preds)
1266*38fd1498Szrj {
1267*38fd1498Szrj rescan_loop_exit (e, true, false);
1268*38fd1498Szrj }
1269*38fd1498Szrj }
1270*38fd1498Szrj
1271*38fd1498Szrj /* Remove basic block BB from loops. */
1272*38fd1498Szrj void
remove_bb_from_loops(basic_block bb)1273*38fd1498Szrj remove_bb_from_loops (basic_block bb)
1274*38fd1498Szrj {
1275*38fd1498Szrj unsigned i;
1276*38fd1498Szrj struct loop *loop = bb->loop_father;
1277*38fd1498Szrj loop_p ploop;
1278*38fd1498Szrj edge_iterator ei;
1279*38fd1498Szrj edge e;
1280*38fd1498Szrj
1281*38fd1498Szrj gcc_assert (loop != NULL);
1282*38fd1498Szrj loop->num_nodes--;
1283*38fd1498Szrj FOR_EACH_VEC_SAFE_ELT (loop->superloops, i, ploop)
1284*38fd1498Szrj ploop->num_nodes--;
1285*38fd1498Szrj bb->loop_father = NULL;
1286*38fd1498Szrj
1287*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1288*38fd1498Szrj {
1289*38fd1498Szrj rescan_loop_exit (e, false, true);
1290*38fd1498Szrj }
1291*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->preds)
1292*38fd1498Szrj {
1293*38fd1498Szrj rescan_loop_exit (e, false, true);
1294*38fd1498Szrj }
1295*38fd1498Szrj }
1296*38fd1498Szrj
1297*38fd1498Szrj /* Finds nearest common ancestor in loop tree for given loops. */
1298*38fd1498Szrj struct loop *
find_common_loop(struct loop * loop_s,struct loop * loop_d)1299*38fd1498Szrj find_common_loop (struct loop *loop_s, struct loop *loop_d)
1300*38fd1498Szrj {
1301*38fd1498Szrj unsigned sdepth, ddepth;
1302*38fd1498Szrj
1303*38fd1498Szrj if (!loop_s) return loop_d;
1304*38fd1498Szrj if (!loop_d) return loop_s;
1305*38fd1498Szrj
1306*38fd1498Szrj sdepth = loop_depth (loop_s);
1307*38fd1498Szrj ddepth = loop_depth (loop_d);
1308*38fd1498Szrj
1309*38fd1498Szrj if (sdepth < ddepth)
1310*38fd1498Szrj loop_d = (*loop_d->superloops)[sdepth];
1311*38fd1498Szrj else if (sdepth > ddepth)
1312*38fd1498Szrj loop_s = (*loop_s->superloops)[ddepth];
1313*38fd1498Szrj
1314*38fd1498Szrj while (loop_s != loop_d)
1315*38fd1498Szrj {
1316*38fd1498Szrj loop_s = loop_outer (loop_s);
1317*38fd1498Szrj loop_d = loop_outer (loop_d);
1318*38fd1498Szrj }
1319*38fd1498Szrj return loop_s;
1320*38fd1498Szrj }
1321*38fd1498Szrj
1322*38fd1498Szrj /* Removes LOOP from structures and frees its data. */
1323*38fd1498Szrj
1324*38fd1498Szrj void
delete_loop(struct loop * loop)1325*38fd1498Szrj delete_loop (struct loop *loop)
1326*38fd1498Szrj {
1327*38fd1498Szrj /* Remove the loop from structure. */
1328*38fd1498Szrj flow_loop_tree_node_remove (loop);
1329*38fd1498Szrj
1330*38fd1498Szrj /* Remove loop from loops array. */
1331*38fd1498Szrj (*current_loops->larray)[loop->num] = NULL;
1332*38fd1498Szrj
1333*38fd1498Szrj /* Free loop data. */
1334*38fd1498Szrj flow_loop_free (loop);
1335*38fd1498Szrj }
1336*38fd1498Szrj
1337*38fd1498Szrj /* Cancels the LOOP; it must be innermost one. */
1338*38fd1498Szrj
1339*38fd1498Szrj static void
cancel_loop(struct loop * loop)1340*38fd1498Szrj cancel_loop (struct loop *loop)
1341*38fd1498Szrj {
1342*38fd1498Szrj basic_block *bbs;
1343*38fd1498Szrj unsigned i;
1344*38fd1498Szrj struct loop *outer = loop_outer (loop);
1345*38fd1498Szrj
1346*38fd1498Szrj gcc_assert (!loop->inner);
1347*38fd1498Szrj
1348*38fd1498Szrj /* Move blocks up one level (they should be removed as soon as possible). */
1349*38fd1498Szrj bbs = get_loop_body (loop);
1350*38fd1498Szrj for (i = 0; i < loop->num_nodes; i++)
1351*38fd1498Szrj bbs[i]->loop_father = outer;
1352*38fd1498Szrj
1353*38fd1498Szrj free (bbs);
1354*38fd1498Szrj delete_loop (loop);
1355*38fd1498Szrj }
1356*38fd1498Szrj
1357*38fd1498Szrj /* Cancels LOOP and all its subloops. */
1358*38fd1498Szrj void
cancel_loop_tree(struct loop * loop)1359*38fd1498Szrj cancel_loop_tree (struct loop *loop)
1360*38fd1498Szrj {
1361*38fd1498Szrj while (loop->inner)
1362*38fd1498Szrj cancel_loop_tree (loop->inner);
1363*38fd1498Szrj cancel_loop (loop);
1364*38fd1498Szrj }
1365*38fd1498Szrj
1366*38fd1498Szrj /* Checks that information about loops is correct
1367*38fd1498Szrj -- sizes of loops are all right
1368*38fd1498Szrj -- results of get_loop_body really belong to the loop
1369*38fd1498Szrj -- loop header have just single entry edge and single latch edge
1370*38fd1498Szrj -- loop latches have only single successor that is header of their loop
1371*38fd1498Szrj -- irreducible loops are correctly marked
1372*38fd1498Szrj -- the cached loop depth and loop father of each bb is correct
1373*38fd1498Szrj */
1374*38fd1498Szrj DEBUG_FUNCTION void
verify_loop_structure(void)1375*38fd1498Szrj verify_loop_structure (void)
1376*38fd1498Szrj {
1377*38fd1498Szrj unsigned *sizes, i, j;
1378*38fd1498Szrj basic_block bb, *bbs;
1379*38fd1498Szrj struct loop *loop;
1380*38fd1498Szrj int err = 0;
1381*38fd1498Szrj edge e;
1382*38fd1498Szrj unsigned num = number_of_loops (cfun);
1383*38fd1498Szrj struct loop_exit *exit, *mexit;
1384*38fd1498Szrj bool dom_available = dom_info_available_p (CDI_DOMINATORS);
1385*38fd1498Szrj
1386*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
1387*38fd1498Szrj {
1388*38fd1498Szrj error ("loop verification on loop tree that needs fixup");
1389*38fd1498Szrj err = 1;
1390*38fd1498Szrj }
1391*38fd1498Szrj
1392*38fd1498Szrj /* We need up-to-date dominators, compute or verify them. */
1393*38fd1498Szrj if (!dom_available)
1394*38fd1498Szrj calculate_dominance_info (CDI_DOMINATORS);
1395*38fd1498Szrj else
1396*38fd1498Szrj verify_dominators (CDI_DOMINATORS);
1397*38fd1498Szrj
1398*38fd1498Szrj /* Check the loop tree root. */
1399*38fd1498Szrj if (current_loops->tree_root->header != ENTRY_BLOCK_PTR_FOR_FN (cfun)
1400*38fd1498Szrj || current_loops->tree_root->latch != EXIT_BLOCK_PTR_FOR_FN (cfun)
1401*38fd1498Szrj || (current_loops->tree_root->num_nodes
1402*38fd1498Szrj != (unsigned) n_basic_blocks_for_fn (cfun)))
1403*38fd1498Szrj {
1404*38fd1498Szrj error ("corrupt loop tree root");
1405*38fd1498Szrj err = 1;
1406*38fd1498Szrj }
1407*38fd1498Szrj
1408*38fd1498Szrj /* Check the headers. */
1409*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
1410*38fd1498Szrj if (bb_loop_header_p (bb))
1411*38fd1498Szrj {
1412*38fd1498Szrj if (bb->loop_father->header == NULL)
1413*38fd1498Szrj {
1414*38fd1498Szrj error ("loop with header %d marked for removal", bb->index);
1415*38fd1498Szrj err = 1;
1416*38fd1498Szrj }
1417*38fd1498Szrj else if (bb->loop_father->header != bb)
1418*38fd1498Szrj {
1419*38fd1498Szrj error ("loop with header %d not in loop tree", bb->index);
1420*38fd1498Szrj err = 1;
1421*38fd1498Szrj }
1422*38fd1498Szrj }
1423*38fd1498Szrj else if (bb->loop_father->header == bb)
1424*38fd1498Szrj {
1425*38fd1498Szrj error ("non-loop with header %d not marked for removal", bb->index);
1426*38fd1498Szrj err = 1;
1427*38fd1498Szrj }
1428*38fd1498Szrj
1429*38fd1498Szrj /* Check the recorded loop father and sizes of loops. */
1430*38fd1498Szrj auto_sbitmap visited (last_basic_block_for_fn (cfun));
1431*38fd1498Szrj bitmap_clear (visited);
1432*38fd1498Szrj bbs = XNEWVEC (basic_block, n_basic_blocks_for_fn (cfun));
1433*38fd1498Szrj FOR_EACH_LOOP (loop, LI_FROM_INNERMOST)
1434*38fd1498Szrj {
1435*38fd1498Szrj unsigned n;
1436*38fd1498Szrj
1437*38fd1498Szrj if (loop->header == NULL)
1438*38fd1498Szrj {
1439*38fd1498Szrj error ("removed loop %d in loop tree", loop->num);
1440*38fd1498Szrj err = 1;
1441*38fd1498Szrj continue;
1442*38fd1498Szrj }
1443*38fd1498Szrj
1444*38fd1498Szrj n = get_loop_body_with_size (loop, bbs, n_basic_blocks_for_fn (cfun));
1445*38fd1498Szrj if (loop->num_nodes != n)
1446*38fd1498Szrj {
1447*38fd1498Szrj error ("size of loop %d should be %d, not %d",
1448*38fd1498Szrj loop->num, n, loop->num_nodes);
1449*38fd1498Szrj err = 1;
1450*38fd1498Szrj }
1451*38fd1498Szrj
1452*38fd1498Szrj for (j = 0; j < n; j++)
1453*38fd1498Szrj {
1454*38fd1498Szrj bb = bbs[j];
1455*38fd1498Szrj
1456*38fd1498Szrj if (!flow_bb_inside_loop_p (loop, bb))
1457*38fd1498Szrj {
1458*38fd1498Szrj error ("bb %d does not belong to loop %d",
1459*38fd1498Szrj bb->index, loop->num);
1460*38fd1498Szrj err = 1;
1461*38fd1498Szrj }
1462*38fd1498Szrj
1463*38fd1498Szrj /* Ignore this block if it is in an inner loop. */
1464*38fd1498Szrj if (bitmap_bit_p (visited, bb->index))
1465*38fd1498Szrj continue;
1466*38fd1498Szrj bitmap_set_bit (visited, bb->index);
1467*38fd1498Szrj
1468*38fd1498Szrj if (bb->loop_father != loop)
1469*38fd1498Szrj {
1470*38fd1498Szrj error ("bb %d has father loop %d, should be loop %d",
1471*38fd1498Szrj bb->index, bb->loop_father->num, loop->num);
1472*38fd1498Szrj err = 1;
1473*38fd1498Szrj }
1474*38fd1498Szrj }
1475*38fd1498Szrj }
1476*38fd1498Szrj free (bbs);
1477*38fd1498Szrj
1478*38fd1498Szrj /* Check headers and latches. */
1479*38fd1498Szrj FOR_EACH_LOOP (loop, 0)
1480*38fd1498Szrj {
1481*38fd1498Szrj i = loop->num;
1482*38fd1498Szrj if (loop->header == NULL)
1483*38fd1498Szrj continue;
1484*38fd1498Szrj if (!bb_loop_header_p (loop->header))
1485*38fd1498Szrj {
1486*38fd1498Szrj error ("loop %d%'s header is not a loop header", i);
1487*38fd1498Szrj err = 1;
1488*38fd1498Szrj }
1489*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS)
1490*38fd1498Szrj && EDGE_COUNT (loop->header->preds) != 2)
1491*38fd1498Szrj {
1492*38fd1498Szrj error ("loop %d%'s header does not have exactly 2 entries", i);
1493*38fd1498Szrj err = 1;
1494*38fd1498Szrj }
1495*38fd1498Szrj if (loop->latch)
1496*38fd1498Szrj {
1497*38fd1498Szrj if (!find_edge (loop->latch, loop->header))
1498*38fd1498Szrj {
1499*38fd1498Szrj error ("loop %d%'s latch does not have an edge to its header", i);
1500*38fd1498Szrj err = 1;
1501*38fd1498Szrj }
1502*38fd1498Szrj if (!dominated_by_p (CDI_DOMINATORS, loop->latch, loop->header))
1503*38fd1498Szrj {
1504*38fd1498Szrj error ("loop %d%'s latch is not dominated by its header", i);
1505*38fd1498Szrj err = 1;
1506*38fd1498Szrj }
1507*38fd1498Szrj }
1508*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES))
1509*38fd1498Szrj {
1510*38fd1498Szrj if (!single_succ_p (loop->latch))
1511*38fd1498Szrj {
1512*38fd1498Szrj error ("loop %d%'s latch does not have exactly 1 successor", i);
1513*38fd1498Szrj err = 1;
1514*38fd1498Szrj }
1515*38fd1498Szrj if (single_succ (loop->latch) != loop->header)
1516*38fd1498Szrj {
1517*38fd1498Szrj error ("loop %d%'s latch does not have header as successor", i);
1518*38fd1498Szrj err = 1;
1519*38fd1498Szrj }
1520*38fd1498Szrj if (loop->latch->loop_father != loop)
1521*38fd1498Szrj {
1522*38fd1498Szrj error ("loop %d%'s latch does not belong directly to it", i);
1523*38fd1498Szrj err = 1;
1524*38fd1498Szrj }
1525*38fd1498Szrj }
1526*38fd1498Szrj if (loop->header->loop_father != loop)
1527*38fd1498Szrj {
1528*38fd1498Szrj error ("loop %d%'s header does not belong directly to it", i);
1529*38fd1498Szrj err = 1;
1530*38fd1498Szrj }
1531*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
1532*38fd1498Szrj && (loop_latch_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP))
1533*38fd1498Szrj {
1534*38fd1498Szrj error ("loop %d%'s latch is marked as part of irreducible region", i);
1535*38fd1498Szrj err = 1;
1536*38fd1498Szrj }
1537*38fd1498Szrj }
1538*38fd1498Szrj
1539*38fd1498Szrj /* Check irreducible loops. */
1540*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS))
1541*38fd1498Szrj {
1542*38fd1498Szrj /* Record old info. */
1543*38fd1498Szrj auto_sbitmap irreds (last_basic_block_for_fn (cfun));
1544*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
1545*38fd1498Szrj {
1546*38fd1498Szrj edge_iterator ei;
1547*38fd1498Szrj if (bb->flags & BB_IRREDUCIBLE_LOOP)
1548*38fd1498Szrj bitmap_set_bit (irreds, bb->index);
1549*38fd1498Szrj else
1550*38fd1498Szrj bitmap_clear_bit (irreds, bb->index);
1551*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1552*38fd1498Szrj if (e->flags & EDGE_IRREDUCIBLE_LOOP)
1553*38fd1498Szrj e->flags |= EDGE_ALL_FLAGS + 1;
1554*38fd1498Szrj }
1555*38fd1498Szrj
1556*38fd1498Szrj /* Recount it. */
1557*38fd1498Szrj mark_irreducible_loops ();
1558*38fd1498Szrj
1559*38fd1498Szrj /* Compare. */
1560*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
1561*38fd1498Szrj {
1562*38fd1498Szrj edge_iterator ei;
1563*38fd1498Szrj
1564*38fd1498Szrj if ((bb->flags & BB_IRREDUCIBLE_LOOP)
1565*38fd1498Szrj && !bitmap_bit_p (irreds, bb->index))
1566*38fd1498Szrj {
1567*38fd1498Szrj error ("basic block %d should be marked irreducible", bb->index);
1568*38fd1498Szrj err = 1;
1569*38fd1498Szrj }
1570*38fd1498Szrj else if (!(bb->flags & BB_IRREDUCIBLE_LOOP)
1571*38fd1498Szrj && bitmap_bit_p (irreds, bb->index))
1572*38fd1498Szrj {
1573*38fd1498Szrj error ("basic block %d should not be marked irreducible", bb->index);
1574*38fd1498Szrj err = 1;
1575*38fd1498Szrj }
1576*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1577*38fd1498Szrj {
1578*38fd1498Szrj if ((e->flags & EDGE_IRREDUCIBLE_LOOP)
1579*38fd1498Szrj && !(e->flags & (EDGE_ALL_FLAGS + 1)))
1580*38fd1498Szrj {
1581*38fd1498Szrj error ("edge from %d to %d should be marked irreducible",
1582*38fd1498Szrj e->src->index, e->dest->index);
1583*38fd1498Szrj err = 1;
1584*38fd1498Szrj }
1585*38fd1498Szrj else if (!(e->flags & EDGE_IRREDUCIBLE_LOOP)
1586*38fd1498Szrj && (e->flags & (EDGE_ALL_FLAGS + 1)))
1587*38fd1498Szrj {
1588*38fd1498Szrj error ("edge from %d to %d should not be marked irreducible",
1589*38fd1498Szrj e->src->index, e->dest->index);
1590*38fd1498Szrj err = 1;
1591*38fd1498Szrj }
1592*38fd1498Szrj e->flags &= ~(EDGE_ALL_FLAGS + 1);
1593*38fd1498Szrj }
1594*38fd1498Szrj }
1595*38fd1498Szrj }
1596*38fd1498Szrj
1597*38fd1498Szrj /* Check the recorded loop exits. */
1598*38fd1498Szrj FOR_EACH_LOOP (loop, 0)
1599*38fd1498Szrj {
1600*38fd1498Szrj if (!loop->exits || loop->exits->e != NULL)
1601*38fd1498Szrj {
1602*38fd1498Szrj error ("corrupted head of the exits list of loop %d",
1603*38fd1498Szrj loop->num);
1604*38fd1498Szrj err = 1;
1605*38fd1498Szrj }
1606*38fd1498Szrj else
1607*38fd1498Szrj {
1608*38fd1498Szrj /* Check that the list forms a cycle, and all elements except
1609*38fd1498Szrj for the head are nonnull. */
1610*38fd1498Szrj for (mexit = loop->exits, exit = mexit->next, i = 0;
1611*38fd1498Szrj exit->e && exit != mexit;
1612*38fd1498Szrj exit = exit->next)
1613*38fd1498Szrj {
1614*38fd1498Szrj if (i++ & 1)
1615*38fd1498Szrj mexit = mexit->next;
1616*38fd1498Szrj }
1617*38fd1498Szrj
1618*38fd1498Szrj if (exit != loop->exits)
1619*38fd1498Szrj {
1620*38fd1498Szrj error ("corrupted exits list of loop %d", loop->num);
1621*38fd1498Szrj err = 1;
1622*38fd1498Szrj }
1623*38fd1498Szrj }
1624*38fd1498Szrj
1625*38fd1498Szrj if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
1626*38fd1498Szrj {
1627*38fd1498Szrj if (loop->exits->next != loop->exits)
1628*38fd1498Szrj {
1629*38fd1498Szrj error ("nonempty exits list of loop %d, but exits are not recorded",
1630*38fd1498Szrj loop->num);
1631*38fd1498Szrj err = 1;
1632*38fd1498Szrj }
1633*38fd1498Szrj }
1634*38fd1498Szrj }
1635*38fd1498Szrj
1636*38fd1498Szrj if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
1637*38fd1498Szrj {
1638*38fd1498Szrj unsigned n_exits = 0, eloops;
1639*38fd1498Szrj
1640*38fd1498Szrj sizes = XCNEWVEC (unsigned, num);
1641*38fd1498Szrj memset (sizes, 0, sizeof (unsigned) * num);
1642*38fd1498Szrj FOR_EACH_BB_FN (bb, cfun)
1643*38fd1498Szrj {
1644*38fd1498Szrj edge_iterator ei;
1645*38fd1498Szrj if (bb->loop_father == current_loops->tree_root)
1646*38fd1498Szrj continue;
1647*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1648*38fd1498Szrj {
1649*38fd1498Szrj if (flow_bb_inside_loop_p (bb->loop_father, e->dest))
1650*38fd1498Szrj continue;
1651*38fd1498Szrj
1652*38fd1498Szrj n_exits++;
1653*38fd1498Szrj exit = get_exit_descriptions (e);
1654*38fd1498Szrj if (!exit)
1655*38fd1498Szrj {
1656*38fd1498Szrj error ("exit %d->%d not recorded",
1657*38fd1498Szrj e->src->index, e->dest->index);
1658*38fd1498Szrj err = 1;
1659*38fd1498Szrj }
1660*38fd1498Szrj eloops = 0;
1661*38fd1498Szrj for (; exit; exit = exit->next_e)
1662*38fd1498Szrj eloops++;
1663*38fd1498Szrj
1664*38fd1498Szrj for (loop = bb->loop_father;
1665*38fd1498Szrj loop != e->dest->loop_father
1666*38fd1498Szrj /* When a loop exit is also an entry edge which
1667*38fd1498Szrj can happen when avoiding CFG manipulations
1668*38fd1498Szrj then the last loop exited is the outer loop
1669*38fd1498Szrj of the loop entered. */
1670*38fd1498Szrj && loop != loop_outer (e->dest->loop_father);
1671*38fd1498Szrj loop = loop_outer (loop))
1672*38fd1498Szrj {
1673*38fd1498Szrj eloops--;
1674*38fd1498Szrj sizes[loop->num]++;
1675*38fd1498Szrj }
1676*38fd1498Szrj
1677*38fd1498Szrj if (eloops != 0)
1678*38fd1498Szrj {
1679*38fd1498Szrj error ("wrong list of exited loops for edge %d->%d",
1680*38fd1498Szrj e->src->index, e->dest->index);
1681*38fd1498Szrj err = 1;
1682*38fd1498Szrj }
1683*38fd1498Szrj }
1684*38fd1498Szrj }
1685*38fd1498Szrj
1686*38fd1498Szrj if (n_exits != current_loops->exits->elements ())
1687*38fd1498Szrj {
1688*38fd1498Szrj error ("too many loop exits recorded");
1689*38fd1498Szrj err = 1;
1690*38fd1498Szrj }
1691*38fd1498Szrj
1692*38fd1498Szrj FOR_EACH_LOOP (loop, 0)
1693*38fd1498Szrj {
1694*38fd1498Szrj eloops = 0;
1695*38fd1498Szrj for (exit = loop->exits->next; exit->e; exit = exit->next)
1696*38fd1498Szrj eloops++;
1697*38fd1498Szrj if (eloops != sizes[loop->num])
1698*38fd1498Szrj {
1699*38fd1498Szrj error ("%d exits recorded for loop %d (having %d exits)",
1700*38fd1498Szrj eloops, loop->num, sizes[loop->num]);
1701*38fd1498Szrj err = 1;
1702*38fd1498Szrj }
1703*38fd1498Szrj }
1704*38fd1498Szrj
1705*38fd1498Szrj free (sizes);
1706*38fd1498Szrj }
1707*38fd1498Szrj
1708*38fd1498Szrj gcc_assert (!err);
1709*38fd1498Szrj
1710*38fd1498Szrj if (!dom_available)
1711*38fd1498Szrj free_dominance_info (CDI_DOMINATORS);
1712*38fd1498Szrj }
1713*38fd1498Szrj
1714*38fd1498Szrj /* Returns latch edge of LOOP. */
1715*38fd1498Szrj edge
loop_latch_edge(const struct loop * loop)1716*38fd1498Szrj loop_latch_edge (const struct loop *loop)
1717*38fd1498Szrj {
1718*38fd1498Szrj return find_edge (loop->latch, loop->header);
1719*38fd1498Szrj }
1720*38fd1498Szrj
1721*38fd1498Szrj /* Returns preheader edge of LOOP. */
1722*38fd1498Szrj edge
loop_preheader_edge(const struct loop * loop)1723*38fd1498Szrj loop_preheader_edge (const struct loop *loop)
1724*38fd1498Szrj {
1725*38fd1498Szrj edge e;
1726*38fd1498Szrj edge_iterator ei;
1727*38fd1498Szrj
1728*38fd1498Szrj gcc_assert (loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS)
1729*38fd1498Szrj && ! loops_state_satisfies_p (LOOPS_MAY_HAVE_MULTIPLE_LATCHES));
1730*38fd1498Szrj
1731*38fd1498Szrj FOR_EACH_EDGE (e, ei, loop->header->preds)
1732*38fd1498Szrj if (e->src != loop->latch)
1733*38fd1498Szrj break;
1734*38fd1498Szrj
1735*38fd1498Szrj if (! e)
1736*38fd1498Szrj {
1737*38fd1498Szrj gcc_assert (! loop_outer (loop));
1738*38fd1498Szrj return single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
1739*38fd1498Szrj }
1740*38fd1498Szrj
1741*38fd1498Szrj return e;
1742*38fd1498Szrj }
1743*38fd1498Szrj
1744*38fd1498Szrj /* Returns true if E is an exit of LOOP. */
1745*38fd1498Szrj
1746*38fd1498Szrj bool
loop_exit_edge_p(const struct loop * loop,const_edge e)1747*38fd1498Szrj loop_exit_edge_p (const struct loop *loop, const_edge e)
1748*38fd1498Szrj {
1749*38fd1498Szrj return (flow_bb_inside_loop_p (loop, e->src)
1750*38fd1498Szrj && !flow_bb_inside_loop_p (loop, e->dest));
1751*38fd1498Szrj }
1752*38fd1498Szrj
1753*38fd1498Szrj /* Returns the single exit edge of LOOP, or NULL if LOOP has either no exit
1754*38fd1498Szrj or more than one exit. If loops do not have the exits recorded, NULL
1755*38fd1498Szrj is returned always. */
1756*38fd1498Szrj
1757*38fd1498Szrj edge
single_exit(const struct loop * loop)1758*38fd1498Szrj single_exit (const struct loop *loop)
1759*38fd1498Szrj {
1760*38fd1498Szrj struct loop_exit *exit = loop->exits->next;
1761*38fd1498Szrj
1762*38fd1498Szrj if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
1763*38fd1498Szrj return NULL;
1764*38fd1498Szrj
1765*38fd1498Szrj if (exit->e && exit->next == loop->exits)
1766*38fd1498Szrj return exit->e;
1767*38fd1498Szrj else
1768*38fd1498Szrj return NULL;
1769*38fd1498Szrj }
1770*38fd1498Szrj
1771*38fd1498Szrj /* Returns true when BB has an incoming edge exiting LOOP. */
1772*38fd1498Szrj
1773*38fd1498Szrj bool
loop_exits_to_bb_p(struct loop * loop,basic_block bb)1774*38fd1498Szrj loop_exits_to_bb_p (struct loop *loop, basic_block bb)
1775*38fd1498Szrj {
1776*38fd1498Szrj edge e;
1777*38fd1498Szrj edge_iterator ei;
1778*38fd1498Szrj
1779*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->preds)
1780*38fd1498Szrj if (loop_exit_edge_p (loop, e))
1781*38fd1498Szrj return true;
1782*38fd1498Szrj
1783*38fd1498Szrj return false;
1784*38fd1498Szrj }
1785*38fd1498Szrj
1786*38fd1498Szrj /* Returns true when BB has an outgoing edge exiting LOOP. */
1787*38fd1498Szrj
1788*38fd1498Szrj bool
loop_exits_from_bb_p(struct loop * loop,basic_block bb)1789*38fd1498Szrj loop_exits_from_bb_p (struct loop *loop, basic_block bb)
1790*38fd1498Szrj {
1791*38fd1498Szrj edge e;
1792*38fd1498Szrj edge_iterator ei;
1793*38fd1498Szrj
1794*38fd1498Szrj FOR_EACH_EDGE (e, ei, bb->succs)
1795*38fd1498Szrj if (loop_exit_edge_p (loop, e))
1796*38fd1498Szrj return true;
1797*38fd1498Szrj
1798*38fd1498Szrj return false;
1799*38fd1498Szrj }
1800*38fd1498Szrj
1801*38fd1498Szrj /* Return location corresponding to the loop control condition if possible. */
1802*38fd1498Szrj
1803*38fd1498Szrj location_t
get_loop_location(struct loop * loop)1804*38fd1498Szrj get_loop_location (struct loop *loop)
1805*38fd1498Szrj {
1806*38fd1498Szrj rtx_insn *insn = NULL;
1807*38fd1498Szrj struct niter_desc *desc = NULL;
1808*38fd1498Szrj edge exit;
1809*38fd1498Szrj
1810*38fd1498Szrj /* For a for or while loop, we would like to return the location
1811*38fd1498Szrj of the for or while statement, if possible. To do this, look
1812*38fd1498Szrj for the branch guarding the loop back-edge. */
1813*38fd1498Szrj
1814*38fd1498Szrj /* If this is a simple loop with an in_edge, then the loop control
1815*38fd1498Szrj branch is typically at the end of its source. */
1816*38fd1498Szrj desc = get_simple_loop_desc (loop);
1817*38fd1498Szrj if (desc->in_edge)
1818*38fd1498Szrj {
1819*38fd1498Szrj FOR_BB_INSNS_REVERSE (desc->in_edge->src, insn)
1820*38fd1498Szrj {
1821*38fd1498Szrj if (INSN_P (insn) && INSN_HAS_LOCATION (insn))
1822*38fd1498Szrj return INSN_LOCATION (insn);
1823*38fd1498Szrj }
1824*38fd1498Szrj }
1825*38fd1498Szrj /* If loop has a single exit, then the loop control branch
1826*38fd1498Szrj must be at the end of its source. */
1827*38fd1498Szrj if ((exit = single_exit (loop)))
1828*38fd1498Szrj {
1829*38fd1498Szrj FOR_BB_INSNS_REVERSE (exit->src, insn)
1830*38fd1498Szrj {
1831*38fd1498Szrj if (INSN_P (insn) && INSN_HAS_LOCATION (insn))
1832*38fd1498Szrj return INSN_LOCATION (insn);
1833*38fd1498Szrj }
1834*38fd1498Szrj }
1835*38fd1498Szrj /* Next check the latch, to see if it is non-empty. */
1836*38fd1498Szrj FOR_BB_INSNS_REVERSE (loop->latch, insn)
1837*38fd1498Szrj {
1838*38fd1498Szrj if (INSN_P (insn) && INSN_HAS_LOCATION (insn))
1839*38fd1498Szrj return INSN_LOCATION (insn);
1840*38fd1498Szrj }
1841*38fd1498Szrj /* Finally, if none of the above identifies the loop control branch,
1842*38fd1498Szrj return the first location in the loop header. */
1843*38fd1498Szrj FOR_BB_INSNS (loop->header, insn)
1844*38fd1498Szrj {
1845*38fd1498Szrj if (INSN_P (insn) && INSN_HAS_LOCATION (insn))
1846*38fd1498Szrj return INSN_LOCATION (insn);
1847*38fd1498Szrj }
1848*38fd1498Szrj /* If all else fails, simply return the current function location. */
1849*38fd1498Szrj return DECL_SOURCE_LOCATION (current_function_decl);
1850*38fd1498Szrj }
1851*38fd1498Szrj
1852*38fd1498Szrj /* Records that every statement in LOOP is executed I_BOUND times.
1853*38fd1498Szrj REALISTIC is true if I_BOUND is expected to be close to the real number
1854*38fd1498Szrj of iterations. UPPER is true if we are sure the loop iterates at most
1855*38fd1498Szrj I_BOUND times. */
1856*38fd1498Szrj
1857*38fd1498Szrj void
record_niter_bound(struct loop * loop,const widest_int & i_bound,bool realistic,bool upper)1858*38fd1498Szrj record_niter_bound (struct loop *loop, const widest_int &i_bound,
1859*38fd1498Szrj bool realistic, bool upper)
1860*38fd1498Szrj {
1861*38fd1498Szrj /* Update the bounds only when there is no previous estimation, or when the
1862*38fd1498Szrj current estimation is smaller. */
1863*38fd1498Szrj if (upper
1864*38fd1498Szrj && (!loop->any_upper_bound
1865*38fd1498Szrj || wi::ltu_p (i_bound, loop->nb_iterations_upper_bound)))
1866*38fd1498Szrj {
1867*38fd1498Szrj loop->any_upper_bound = true;
1868*38fd1498Szrj loop->nb_iterations_upper_bound = i_bound;
1869*38fd1498Szrj if (!loop->any_likely_upper_bound)
1870*38fd1498Szrj {
1871*38fd1498Szrj loop->any_likely_upper_bound = true;
1872*38fd1498Szrj loop->nb_iterations_likely_upper_bound = i_bound;
1873*38fd1498Szrj }
1874*38fd1498Szrj }
1875*38fd1498Szrj if (realistic
1876*38fd1498Szrj && (!loop->any_estimate
1877*38fd1498Szrj || wi::ltu_p (i_bound, loop->nb_iterations_estimate)))
1878*38fd1498Szrj {
1879*38fd1498Szrj loop->any_estimate = true;
1880*38fd1498Szrj loop->nb_iterations_estimate = i_bound;
1881*38fd1498Szrj }
1882*38fd1498Szrj if (!realistic
1883*38fd1498Szrj && (!loop->any_likely_upper_bound
1884*38fd1498Szrj || wi::ltu_p (i_bound, loop->nb_iterations_likely_upper_bound)))
1885*38fd1498Szrj {
1886*38fd1498Szrj loop->any_likely_upper_bound = true;
1887*38fd1498Szrj loop->nb_iterations_likely_upper_bound = i_bound;
1888*38fd1498Szrj }
1889*38fd1498Szrj
1890*38fd1498Szrj /* If an upper bound is smaller than the realistic estimate of the
1891*38fd1498Szrj number of iterations, use the upper bound instead. */
1892*38fd1498Szrj if (loop->any_upper_bound
1893*38fd1498Szrj && loop->any_estimate
1894*38fd1498Szrj && wi::ltu_p (loop->nb_iterations_upper_bound,
1895*38fd1498Szrj loop->nb_iterations_estimate))
1896*38fd1498Szrj loop->nb_iterations_estimate = loop->nb_iterations_upper_bound;
1897*38fd1498Szrj if (loop->any_upper_bound
1898*38fd1498Szrj && loop->any_likely_upper_bound
1899*38fd1498Szrj && wi::ltu_p (loop->nb_iterations_upper_bound,
1900*38fd1498Szrj loop->nb_iterations_likely_upper_bound))
1901*38fd1498Szrj loop->nb_iterations_likely_upper_bound = loop->nb_iterations_upper_bound;
1902*38fd1498Szrj }
1903*38fd1498Szrj
1904*38fd1498Szrj /* Similar to get_estimated_loop_iterations, but returns the estimate only
1905*38fd1498Szrj if it fits to HOST_WIDE_INT. If this is not the case, or the estimate
1906*38fd1498Szrj on the number of iterations of LOOP could not be derived, returns -1. */
1907*38fd1498Szrj
1908*38fd1498Szrj HOST_WIDE_INT
get_estimated_loop_iterations_int(struct loop * loop)1909*38fd1498Szrj get_estimated_loop_iterations_int (struct loop *loop)
1910*38fd1498Szrj {
1911*38fd1498Szrj widest_int nit;
1912*38fd1498Szrj HOST_WIDE_INT hwi_nit;
1913*38fd1498Szrj
1914*38fd1498Szrj if (!get_estimated_loop_iterations (loop, &nit))
1915*38fd1498Szrj return -1;
1916*38fd1498Szrj
1917*38fd1498Szrj if (!wi::fits_shwi_p (nit))
1918*38fd1498Szrj return -1;
1919*38fd1498Szrj hwi_nit = nit.to_shwi ();
1920*38fd1498Szrj
1921*38fd1498Szrj return hwi_nit < 0 ? -1 : hwi_nit;
1922*38fd1498Szrj }
1923*38fd1498Szrj
1924*38fd1498Szrj /* Returns an upper bound on the number of executions of statements
1925*38fd1498Szrj in the LOOP. For statements before the loop exit, this exceeds
1926*38fd1498Szrj the number of execution of the latch by one. */
1927*38fd1498Szrj
1928*38fd1498Szrj HOST_WIDE_INT
max_stmt_executions_int(struct loop * loop)1929*38fd1498Szrj max_stmt_executions_int (struct loop *loop)
1930*38fd1498Szrj {
1931*38fd1498Szrj HOST_WIDE_INT nit = get_max_loop_iterations_int (loop);
1932*38fd1498Szrj HOST_WIDE_INT snit;
1933*38fd1498Szrj
1934*38fd1498Szrj if (nit == -1)
1935*38fd1498Szrj return -1;
1936*38fd1498Szrj
1937*38fd1498Szrj snit = (HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) nit + 1);
1938*38fd1498Szrj
1939*38fd1498Szrj /* If the computation overflows, return -1. */
1940*38fd1498Szrj return snit < 0 ? -1 : snit;
1941*38fd1498Szrj }
1942*38fd1498Szrj
1943*38fd1498Szrj /* Returns an likely upper bound on the number of executions of statements
1944*38fd1498Szrj in the LOOP. For statements before the loop exit, this exceeds
1945*38fd1498Szrj the number of execution of the latch by one. */
1946*38fd1498Szrj
1947*38fd1498Szrj HOST_WIDE_INT
likely_max_stmt_executions_int(struct loop * loop)1948*38fd1498Szrj likely_max_stmt_executions_int (struct loop *loop)
1949*38fd1498Szrj {
1950*38fd1498Szrj HOST_WIDE_INT nit = get_likely_max_loop_iterations_int (loop);
1951*38fd1498Szrj HOST_WIDE_INT snit;
1952*38fd1498Szrj
1953*38fd1498Szrj if (nit == -1)
1954*38fd1498Szrj return -1;
1955*38fd1498Szrj
1956*38fd1498Szrj snit = (HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) nit + 1);
1957*38fd1498Szrj
1958*38fd1498Szrj /* If the computation overflows, return -1. */
1959*38fd1498Szrj return snit < 0 ? -1 : snit;
1960*38fd1498Szrj }
1961*38fd1498Szrj
1962*38fd1498Szrj /* Sets NIT to the estimated number of executions of the latch of the
1963*38fd1498Szrj LOOP. If we have no reliable estimate, the function returns false, otherwise
1964*38fd1498Szrj returns true. */
1965*38fd1498Szrj
1966*38fd1498Szrj bool
get_estimated_loop_iterations(struct loop * loop,widest_int * nit)1967*38fd1498Szrj get_estimated_loop_iterations (struct loop *loop, widest_int *nit)
1968*38fd1498Szrj {
1969*38fd1498Szrj /* Even if the bound is not recorded, possibly we can derrive one from
1970*38fd1498Szrj profile. */
1971*38fd1498Szrj if (!loop->any_estimate)
1972*38fd1498Szrj {
1973*38fd1498Szrj if (loop->header->count.reliable_p ())
1974*38fd1498Szrj {
1975*38fd1498Szrj *nit = gcov_type_to_wide_int
1976*38fd1498Szrj (expected_loop_iterations_unbounded (loop) + 1);
1977*38fd1498Szrj return true;
1978*38fd1498Szrj }
1979*38fd1498Szrj return false;
1980*38fd1498Szrj }
1981*38fd1498Szrj
1982*38fd1498Szrj *nit = loop->nb_iterations_estimate;
1983*38fd1498Szrj return true;
1984*38fd1498Szrj }
1985*38fd1498Szrj
1986*38fd1498Szrj /* Sets NIT to an upper bound for the maximum number of executions of the
1987*38fd1498Szrj latch of the LOOP. If we have no reliable estimate, the function returns
1988*38fd1498Szrj false, otherwise returns true. */
1989*38fd1498Szrj
1990*38fd1498Szrj bool
get_max_loop_iterations(const struct loop * loop,widest_int * nit)1991*38fd1498Szrj get_max_loop_iterations (const struct loop *loop, widest_int *nit)
1992*38fd1498Szrj {
1993*38fd1498Szrj if (!loop->any_upper_bound)
1994*38fd1498Szrj return false;
1995*38fd1498Szrj
1996*38fd1498Szrj *nit = loop->nb_iterations_upper_bound;
1997*38fd1498Szrj return true;
1998*38fd1498Szrj }
1999*38fd1498Szrj
2000*38fd1498Szrj /* Similar to get_max_loop_iterations, but returns the estimate only
2001*38fd1498Szrj if it fits to HOST_WIDE_INT. If this is not the case, or the estimate
2002*38fd1498Szrj on the number of iterations of LOOP could not be derived, returns -1. */
2003*38fd1498Szrj
2004*38fd1498Szrj HOST_WIDE_INT
get_max_loop_iterations_int(const struct loop * loop)2005*38fd1498Szrj get_max_loop_iterations_int (const struct loop *loop)
2006*38fd1498Szrj {
2007*38fd1498Szrj widest_int nit;
2008*38fd1498Szrj HOST_WIDE_INT hwi_nit;
2009*38fd1498Szrj
2010*38fd1498Szrj if (!get_max_loop_iterations (loop, &nit))
2011*38fd1498Szrj return -1;
2012*38fd1498Szrj
2013*38fd1498Szrj if (!wi::fits_shwi_p (nit))
2014*38fd1498Szrj return -1;
2015*38fd1498Szrj hwi_nit = nit.to_shwi ();
2016*38fd1498Szrj
2017*38fd1498Szrj return hwi_nit < 0 ? -1 : hwi_nit;
2018*38fd1498Szrj }
2019*38fd1498Szrj
2020*38fd1498Szrj /* Sets NIT to an upper bound for the maximum number of executions of the
2021*38fd1498Szrj latch of the LOOP. If we have no reliable estimate, the function returns
2022*38fd1498Szrj false, otherwise returns true. */
2023*38fd1498Szrj
2024*38fd1498Szrj bool
get_likely_max_loop_iterations(struct loop * loop,widest_int * nit)2025*38fd1498Szrj get_likely_max_loop_iterations (struct loop *loop, widest_int *nit)
2026*38fd1498Szrj {
2027*38fd1498Szrj if (!loop->any_likely_upper_bound)
2028*38fd1498Szrj return false;
2029*38fd1498Szrj
2030*38fd1498Szrj *nit = loop->nb_iterations_likely_upper_bound;
2031*38fd1498Szrj return true;
2032*38fd1498Szrj }
2033*38fd1498Szrj
2034*38fd1498Szrj /* Similar to get_max_loop_iterations, but returns the estimate only
2035*38fd1498Szrj if it fits to HOST_WIDE_INT. If this is not the case, or the estimate
2036*38fd1498Szrj on the number of iterations of LOOP could not be derived, returns -1. */
2037*38fd1498Szrj
2038*38fd1498Szrj HOST_WIDE_INT
get_likely_max_loop_iterations_int(struct loop * loop)2039*38fd1498Szrj get_likely_max_loop_iterations_int (struct loop *loop)
2040*38fd1498Szrj {
2041*38fd1498Szrj widest_int nit;
2042*38fd1498Szrj HOST_WIDE_INT hwi_nit;
2043*38fd1498Szrj
2044*38fd1498Szrj if (!get_likely_max_loop_iterations (loop, &nit))
2045*38fd1498Szrj return -1;
2046*38fd1498Szrj
2047*38fd1498Szrj if (!wi::fits_shwi_p (nit))
2048*38fd1498Szrj return -1;
2049*38fd1498Szrj hwi_nit = nit.to_shwi ();
2050*38fd1498Szrj
2051*38fd1498Szrj return hwi_nit < 0 ? -1 : hwi_nit;
2052*38fd1498Szrj }
2053*38fd1498Szrj
2054*38fd1498Szrj /* Returns the loop depth of the loop BB belongs to. */
2055*38fd1498Szrj
2056*38fd1498Szrj int
bb_loop_depth(const_basic_block bb)2057*38fd1498Szrj bb_loop_depth (const_basic_block bb)
2058*38fd1498Szrj {
2059*38fd1498Szrj return bb->loop_father ? loop_depth (bb->loop_father) : 0;
2060*38fd1498Szrj }
2061*38fd1498Szrj
2062*38fd1498Szrj /* Marks LOOP for removal and sets LOOPS_NEED_FIXUP. */
2063*38fd1498Szrj
2064*38fd1498Szrj void
mark_loop_for_removal(loop_p loop)2065*38fd1498Szrj mark_loop_for_removal (loop_p loop)
2066*38fd1498Szrj {
2067*38fd1498Szrj if (loop->header == NULL)
2068*38fd1498Szrj return;
2069*38fd1498Szrj loop->former_header = loop->header;
2070*38fd1498Szrj loop->header = NULL;
2071*38fd1498Szrj loop->latch = NULL;
2072*38fd1498Szrj loops_state_set (LOOPS_NEED_FIXUP);
2073*38fd1498Szrj }
2074